diff --git a/.gitignore b/.gitignore index 9e0b828..165652f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,9 @@ -/target/ +*/target/ !.mvn/wrapper/maven-wrapper.jar +### VS code ### +.history + ### STS ### .apt_generated .classpath @@ -16,6 +19,7 @@ *.iml *.ipr .DS_Store +*.csv ### NetBeans ### /nbproject/private/ diff --git a/java-8future/delombok/src-bak/src/main/java/com/heks/future/CompletableFutureTest.java b/java-8future/delombok/src-bak/src/main/java/com/heks/future/CompletableFutureTest.java new file mode 100644 index 0000000..e2635ac --- /dev/null +++ b/java-8future/delombok/src-bak/src/main/java/com/heks/future/CompletableFutureTest.java @@ -0,0 +1,97 @@ +package com.heks.future; + +import java.util.concurrent.*; + +/** + * @author heks + * @description: CompletableFuture弥补了Future模式的缺点。在异步的任务完成后，需要用其结果继续操作时，无需等待。可以直接通过thenAccept、thenApply、thenCompose等方式将前面异步处理的结果交给另外一个异步事件处理线程来处理。 + * + * @date 2020/11/10 + */ +public class CompletableFutureTest { + /*runAsync返回的CompletableFuture是没有返回值*/ + /*public static void main(String[] args) { + CompletableFuture future = CompletableFuture.runAsync(() -> { + System.out.println("Hello"); + }); + + try { + future.get(); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + + System.out.println("CompletableFuture"); + }*/ + + /*supplyAsync返回的CompletableFuture是有返回值的*/ + /*public static void main(String[] args) { + CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello"); + + try { + System.out.println(future.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + + System.out.println("CompletableFuture"); + }*/ + + /*future.get()在等待执行结果时，程序会一直block，如果此时调用complete(T t)会立即执行 + * return World*/ + /*public static void main(String[] args) { + CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello"); + + future.complete("World"); + + try { + System.out.println(future.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + }*/ + + /*future已经执行完毕能够返回结果，此时再调用complete(T t)则会无效 + * return Hello*/ + /*public static void main(String[] args) { + CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello"); + + try { + Thread.sleep(5000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + future.complete("World"); + + try { + System.out.println(future.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + }*/ + + /*使用completeExceptionally(Throwable ex)则抛出一个异常，而不是一个成功的结果。*/ + public static void main(String[] args) { + ExecutorService executor = Executors.newCachedThreadPool(); + CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello"); + future.thenAcceptAsync((s)-> System.out.println(s), executor); + future.completeExceptionally(new Exception()); + + try { + System.out.println(future.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + } +} diff --git a/java-8future/delombok/src-bak/src/main/java/com/heks/future/FutureTest.java b/java-8future/delombok/src-bak/src/main/java/com/heks/future/FutureTest.java new file mode 100644 index 0000000..20969c2 --- /dev/null +++ b/java-8future/delombok/src-bak/src/main/java/com/heks/future/FutureTest.java @@ -0,0 +1,37 @@ +package com.heks.future; + +import java.util.concurrent.*; + +/** + * @author heks + * @description: Future虽然可以实现获取异步执行结果的需求，但是它没有提供通知的机制，我们无法得知Future什么时候完成。 + * 要么使用阻塞，在future.get()的地方等待future返回的结果，这时又变成同步操作。要么使用isDone()轮询地判断Future是否完成，这样会耗费CPU的资源。 + * @date 2020/11/10 + */ +public class FutureTest { + public static void main(String[] args) { + ExecutorService executor = Executors.newCachedThreadPool(); + + Future future = executor.submit(() -> { //Lambda 是一个 callable， 提交后便立即执行，这里返回的是 FutureTask 实例 + System.out.println("running task"); + Thread.sleep(10000); + return "return task"; + }); + + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + } + + System.out.println("do something else"); //前面的的 Callable 在其他线程中运行着，可以做一些其他的事情 + + try { + System.out.println(future.get()); //等待 future 的执行结果，执行完毕之后打印出来 + } catch (InterruptedException e) { + } catch (ExecutionException e) { + + } finally { + executor.shutdown(); + } + } +} diff --git a/java-8future/delombok/src-bak/src/test/java/CompletionStageTest.java b/java-8future/delombok/src-bak/src/test/java/CompletionStageTest.java new file mode 100644 index 0000000..ffcb9ef --- /dev/null +++ b/java-8future/delombok/src-bak/src/test/java/CompletionStageTest.java @@ -0,0 +1,139 @@ +import org.junit.Test; + +import java.util.concurrent.CompletableFuture; + +/** + * @author heks + * @description: TODO + * @date 2020/11/10 + */ +public class CompletionStageTest { + + /*thenAccept是针对结果进行消耗，因为他的入参是Consumer，有入参无返回值 + * renturn hello world + */ + @Test + public void thenAccept(){ + CompletableFuture.supplyAsync(() -> "hello").thenAccept(s -> System.out.println(s+" world")); + } + + /*thenRun它的入参是一个Runnable的实例，表示当得到上一步的结果时的操作 + * return hello world + * */ + @Test + public void thenRun(){ + CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "hello"; + }).thenRun(() -> System.out.println("hello world")); + while (true){} + } + + /*结合两个CompletionStage的结果，进行转化后返回 + * renturn hello world + */ + @Test + public void thenCombine() { + String result = CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "hello"; + }).thenCombine(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "world"; + }), (s1, s2) -> s1 + " " + s2).join(); + System.out.println(result); + } + @Test + public void thenAcceptBoth() { + CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "hello"; + }).thenAcceptBoth(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "world"; + }), (s1, s2) -> System.out.println(s1 + " " + s2)); + while (true){} + } + @Test + public void runAfterBoth(){ + CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s1"; + }).runAfterBothAsync(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s2"; + }), () -> System.out.println("hello world")); + while (true){} + } + + /*我们现实开发场景中，总会碰到有两种渠道完成同一个事情，所以就可以调用这个方法，找一个最快的结果进行处理*/ + @Test + public void applyToEither() { + String result = CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s1"; + }).applyToEither(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "hello world"; + }), s -> s).join(); + System.out.println(result); + } + +/*两个CompletionStage，任何一个完成了都会执行下一步的操作（Runnable）。*/ + @Test + public void runAfterEither() { + CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s1"; + }).runAfterEither(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s2"; + }), () -> System.out.println("hello world")); + while (true) { + } + } +} diff --git a/java-8future/delombok/src-bak/src/test/java/ConsumerTest.java b/java-8future/delombok/src-bak/src/test/java/ConsumerTest.java new file mode 100644 index 0000000..2ac76a4 --- /dev/null +++ b/java-8future/delombok/src-bak/src/test/java/ConsumerTest.java @@ -0,0 +1,45 @@ +import org.junit.Test; + +import java.util.function.Consumer; +import java.util.stream.Stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/10 + */ +public class ConsumerTest { + /** + * consumer接口测试 + */ + @Test + public void test_Consumer() { + //① 使用consumer接口实现方法 + Consumer consumer = new Consumer() { + + @Override + public void accept(String s) { + System.out.println(s); + } + }; + Stream stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff"); + stream.forEach(consumer); + + System.out.println("********************"); + + //② 使用lambda表达式，forEach方法需要的就是一个Consumer接口 + stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff"); + Consumer consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口 + stream.forEach(consumer1); + //更直接的方式 + //stream.forEach((s) -> System.out.println(s)); + System.out.println("********************"); + + //③ 使用方法引用，方法引用也是一个consumer + stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff"); + Consumer consumer2 = System.out::println; + stream.forEach(consumer); + //更直接的方式 + //stream.forEach(System.out::println); + } +} diff --git a/java-8future/delombok/src-bak/src/test/java/FunctionTest.java b/java-8future/delombok/src-bak/src/test/java/FunctionTest.java new file mode 100644 index 0000000..83e6bdf --- /dev/null +++ b/java-8future/delombok/src-bak/src/test/java/FunctionTest.java @@ -0,0 +1,33 @@ +import org.junit.Test; + +import java.util.function.Function; +import java.util.stream.Stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class FunctionTest { + /** + * Function测试，function的作用是转换，将一个值转为另外一个值 + */ + @Test + public void test_Function() { + //① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型 + Function function = new Function() { + @Override + public Integer apply(String s) { + return s.length();//获取每个字符串的长度，并且返回 + } + }; + + Stream stream = Stream.of("aaa", "bbbbb", "ccccccv"); + Stream stream1 = stream.map(function); + stream1.forEach(System.out::println); + + System.out.println("********************"); + + System.out.println(function.apply("heks")); + } +} diff --git a/java-8future/delombok/src-bak/src/test/java/PredicateTest.java b/java-8future/delombok/src-bak/src/test/java/PredicateTest.java new file mode 100644 index 0000000..c10e156 --- /dev/null +++ b/java-8future/delombok/src-bak/src/test/java/PredicateTest.java @@ -0,0 +1,64 @@ +import org.junit.Test; + +import java.util.List; +import java.util.function.Predicate; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class PredicateTest { + /** + * Predicate谓词测试，谓词其实就是一个判断的作用类似bool的作用 + */ + @Test + public void test_Predicate() { + //① 使用Predicate接口实现方法,只有一个test方法，传入一个参数，返回一个bool值 + Predicate predicate = new Predicate() { + @Override + public boolean test(Integer integer) { + if(integer > 5){ + return true; + } + return false; + } + }; + + System.out.println(predicate.test(6)); + + System.out.println("********************"); + + //② 使用lambda表达式， + predicate = (t) -> t > 5; + System.out.println(predicate.test(1)); + System.out.println("********************"); + + } + + /** + * Predicate谓词测试，Predicate作为接口使用 + */ + @Test + public void test_Predicate2() { + //① 将Predicate作为filter接口，Predicate起到一个判断的作用 + Predicate predicate = new Predicate() { + @Override + public boolean test(Integer integer) { + if(integer > 5){ + return true; + } + return false; + } + }; + + Stream stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6); + List list = stream.filter(predicate).collect(Collectors.toList()); + list.forEach(System.out::println); + + System.out.println("********************"); + + } +} diff --git a/java-8future/delombok/src-bak/src/test/java/SupplierTest.java b/java-8future/delombok/src-bak/src/test/java/SupplierTest.java new file mode 100644 index 0000000..dfeae32 --- /dev/null +++ b/java-8future/delombok/src-bak/src/test/java/SupplierTest.java @@ -0,0 +1,70 @@ +import org.junit.Test; + +import java.util.Optional; +import java.util.Random; +import java.util.function.Supplier; +import java.util.stream.Stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class SupplierTest { + /** + * Supplier接口测试，supplier相当一个容器或者变量，可以存储值 + */ + @Test + public void test_Supplier() { + //① 使用Supplier接口实现方法,只有一个get方法，无参数，返回一个值 + Supplier supplier = new Supplier() { + @Override + public Integer get() { + //返回一个随机值 + return new Random().nextInt(); + } + }; + + System.out.println(supplier.get()); + + System.out.println("********************"); + + //② 使用lambda表达式， + supplier = () -> new Random().nextInt(); + System.out.println(supplier.get()); + System.out.println("********************"); + + //③ 使用方法引用 + Supplier supplier2 = Math::random; + System.out.println(supplier2.get()); + } + + /** + * Supplier接口测试2，使用需要Supplier的接口方法 + */ + @Test + public void test_Supplier2() { + Stream stream = Stream.of(1, 2, 3, 4, 5); + //返回一个optional对象 + Optional first = stream.filter(i -> i > 4) + .findFirst(); + + //optional对象有需要Supplier接口的方法 + //orElse，如果first中存在数，就返回这个数，如果不存在，就放回传入的数 + System.out.println(first.orElse(1)); + System.out.println(first.orElse(7)); + + System.out.println("********************"); + + Supplier supplier = new Supplier() { + @Override + public Integer get() { + //返回一个随机值 + return new Random().nextInt(); + } + }; + + //orElseGet，如果first中存在数，就返回这个数，如果不存在，就返回supplier返回的值 + System.out.println(first.orElseGet(supplier)); + } +} diff --git a/java-8future/delombok/src-bak/src/test/java/User.java b/java-8future/delombok/src-bak/src/test/java/User.java new file mode 100644 index 0000000..cad3109 --- /dev/null +++ b/java-8future/delombok/src-bak/src/test/java/User.java @@ -0,0 +1,8 @@ +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class User { + +} diff --git a/java-8future/pom.xml b/java-8future/pom.xml new file mode 100644 index 0000000..a75c52f --- /dev/null +++ b/java-8future/pom.xml @@ -0,0 +1,32 @@ + + + 4.0.0 + + org.example + java-8future + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 8 + 8 + + + + + + + junit + junit + 4.12 + test + + + + + \ No newline at end of file diff --git a/java-8future/src/main/java/com/heks/future/CompletableFutureTest.java b/java-8future/src/main/java/com/heks/future/CompletableFutureTest.java new file mode 100644 index 0000000..e2635ac --- /dev/null +++ b/java-8future/src/main/java/com/heks/future/CompletableFutureTest.java @@ -0,0 +1,97 @@ +package com.heks.future; + +import java.util.concurrent.*; + +/** + * @author heks + * @description: CompletableFuture弥补了Future模式的缺点。在异步的任务完成后，需要用其结果继续操作时，无需等待。可以直接通过thenAccept、thenApply、thenCompose等方式将前面异步处理的结果交给另外一个异步事件处理线程来处理。 + * + * @date 2020/11/10 + */ +public class CompletableFutureTest { + /*runAsync返回的CompletableFuture是没有返回值*/ + /*public static void main(String[] args) { + CompletableFuture future = CompletableFuture.runAsync(() -> { + System.out.println("Hello"); + }); + + try { + future.get(); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + + System.out.println("CompletableFuture"); + }*/ + + /*supplyAsync返回的CompletableFuture是有返回值的*/ + /*public static void main(String[] args) { + CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello"); + + try { + System.out.println(future.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + + System.out.println("CompletableFuture"); + }*/ + + /*future.get()在等待执行结果时，程序会一直block，如果此时调用complete(T t)会立即执行 + * return World*/ + /*public static void main(String[] args) { + CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello"); + + future.complete("World"); + + try { + System.out.println(future.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + }*/ + + /*future已经执行完毕能够返回结果，此时再调用complete(T t)则会无效 + * return Hello*/ + /*public static void main(String[] args) { + CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello"); + + try { + Thread.sleep(5000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + future.complete("World"); + + try { + System.out.println(future.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + }*/ + + /*使用completeExceptionally(Throwable ex)则抛出一个异常，而不是一个成功的结果。*/ + public static void main(String[] args) { + ExecutorService executor = Executors.newCachedThreadPool(); + CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello"); + future.thenAcceptAsync((s)-> System.out.println(s), executor); + future.completeExceptionally(new Exception()); + + try { + System.out.println(future.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + } +} diff --git a/java-8future/src/main/java/com/heks/future/FutureTest.java b/java-8future/src/main/java/com/heks/future/FutureTest.java new file mode 100644 index 0000000..20969c2 --- /dev/null +++ b/java-8future/src/main/java/com/heks/future/FutureTest.java @@ -0,0 +1,37 @@ +package com.heks.future; + +import java.util.concurrent.*; + +/** + * @author heks + * @description: Future虽然可以实现获取异步执行结果的需求，但是它没有提供通知的机制，我们无法得知Future什么时候完成。 + * 要么使用阻塞，在future.get()的地方等待future返回的结果，这时又变成同步操作。要么使用isDone()轮询地判断Future是否完成，这样会耗费CPU的资源。 + * @date 2020/11/10 + */ +public class FutureTest { + public static void main(String[] args) { + ExecutorService executor = Executors.newCachedThreadPool(); + + Future future = executor.submit(() -> { //Lambda 是一个 callable， 提交后便立即执行，这里返回的是 FutureTask 实例 + System.out.println("running task"); + Thread.sleep(10000); + return "return task"; + }); + + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + } + + System.out.println("do something else"); //前面的的 Callable 在其他线程中运行着，可以做一些其他的事情 + + try { + System.out.println(future.get()); //等待 future 的执行结果，执行完毕之后打印出来 + } catch (InterruptedException e) { + } catch (ExecutionException e) { + + } finally { + executor.shutdown(); + } + } +} diff --git a/java-8future/src/test/java/CompletionStageTest.java b/java-8future/src/test/java/CompletionStageTest.java new file mode 100644 index 0000000..ffcb9ef --- /dev/null +++ b/java-8future/src/test/java/CompletionStageTest.java @@ -0,0 +1,139 @@ +import org.junit.Test; + +import java.util.concurrent.CompletableFuture; + +/** + * @author heks + * @description: TODO + * @date 2020/11/10 + */ +public class CompletionStageTest { + + /*thenAccept是针对结果进行消耗，因为他的入参是Consumer，有入参无返回值 + * renturn hello world + */ + @Test + public void thenAccept(){ + CompletableFuture.supplyAsync(() -> "hello").thenAccept(s -> System.out.println(s+" world")); + } + + /*thenRun它的入参是一个Runnable的实例，表示当得到上一步的结果时的操作 + * return hello world + * */ + @Test + public void thenRun(){ + CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "hello"; + }).thenRun(() -> System.out.println("hello world")); + while (true){} + } + + /*结合两个CompletionStage的结果，进行转化后返回 + * renturn hello world + */ + @Test + public void thenCombine() { + String result = CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "hello"; + }).thenCombine(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "world"; + }), (s1, s2) -> s1 + " " + s2).join(); + System.out.println(result); + } + @Test + public void thenAcceptBoth() { + CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "hello"; + }).thenAcceptBoth(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "world"; + }), (s1, s2) -> System.out.println(s1 + " " + s2)); + while (true){} + } + @Test + public void runAfterBoth(){ + CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s1"; + }).runAfterBothAsync(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s2"; + }), () -> System.out.println("hello world")); + while (true){} + } + + /*我们现实开发场景中，总会碰到有两种渠道完成同一个事情，所以就可以调用这个方法，找一个最快的结果进行处理*/ + @Test + public void applyToEither() { + String result = CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s1"; + }).applyToEither(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "hello world"; + }), s -> s).join(); + System.out.println(result); + } + +/*两个CompletionStage，任何一个完成了都会执行下一步的操作（Runnable）。*/ + @Test + public void runAfterEither() { + CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s1"; + }).runAfterEither(CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return "s2"; + }), () -> System.out.println("hello world")); + while (true) { + } + } +} diff --git a/java-8future/src/test/java/ConsumerTest.java b/java-8future/src/test/java/ConsumerTest.java new file mode 100644 index 0000000..2ac76a4 --- /dev/null +++ b/java-8future/src/test/java/ConsumerTest.java @@ -0,0 +1,45 @@ +import org.junit.Test; + +import java.util.function.Consumer; +import java.util.stream.Stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/10 + */ +public class ConsumerTest { + /** + * consumer接口测试 + */ + @Test + public void test_Consumer() { + //① 使用consumer接口实现方法 + Consumer consumer = new Consumer() { + + @Override + public void accept(String s) { + System.out.println(s); + } + }; + Stream stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff"); + stream.forEach(consumer); + + System.out.println("********************"); + + //② 使用lambda表达式，forEach方法需要的就是一个Consumer接口 + stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff"); + Consumer consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口 + stream.forEach(consumer1); + //更直接的方式 + //stream.forEach((s) -> System.out.println(s)); + System.out.println("********************"); + + //③ 使用方法引用，方法引用也是一个consumer + stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff"); + Consumer consumer2 = System.out::println; + stream.forEach(consumer); + //更直接的方式 + //stream.forEach(System.out::println); + } +} diff --git a/java-8future/src/test/java/FunctionTest.java b/java-8future/src/test/java/FunctionTest.java new file mode 100644 index 0000000..83e6bdf --- /dev/null +++ b/java-8future/src/test/java/FunctionTest.java @@ -0,0 +1,33 @@ +import org.junit.Test; + +import java.util.function.Function; +import java.util.stream.Stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class FunctionTest { + /** + * Function测试，function的作用是转换，将一个值转为另外一个值 + */ + @Test + public void test_Function() { + //① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型 + Function function = new Function() { + @Override + public Integer apply(String s) { + return s.length();//获取每个字符串的长度，并且返回 + } + }; + + Stream stream = Stream.of("aaa", "bbbbb", "ccccccv"); + Stream stream1 = stream.map(function); + stream1.forEach(System.out::println); + + System.out.println("********************"); + + System.out.println(function.apply("heks")); + } +} diff --git a/java-8future/src/test/java/PredicateTest.java b/java-8future/src/test/java/PredicateTest.java new file mode 100644 index 0000000..c10e156 --- /dev/null +++ b/java-8future/src/test/java/PredicateTest.java @@ -0,0 +1,64 @@ +import org.junit.Test; + +import java.util.List; +import java.util.function.Predicate; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class PredicateTest { + /** + * Predicate谓词测试，谓词其实就是一个判断的作用类似bool的作用 + */ + @Test + public void test_Predicate() { + //① 使用Predicate接口实现方法,只有一个test方法，传入一个参数，返回一个bool值 + Predicate predicate = new Predicate() { + @Override + public boolean test(Integer integer) { + if(integer > 5){ + return true; + } + return false; + } + }; + + System.out.println(predicate.test(6)); + + System.out.println("********************"); + + //② 使用lambda表达式， + predicate = (t) -> t > 5; + System.out.println(predicate.test(1)); + System.out.println("********************"); + + } + + /** + * Predicate谓词测试，Predicate作为接口使用 + */ + @Test + public void test_Predicate2() { + //① 将Predicate作为filter接口，Predicate起到一个判断的作用 + Predicate predicate = new Predicate() { + @Override + public boolean test(Integer integer) { + if(integer > 5){ + return true; + } + return false; + } + }; + + Stream stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6); + List list = stream.filter(predicate).collect(Collectors.toList()); + list.forEach(System.out::println); + + System.out.println("********************"); + + } +} diff --git a/java-8future/src/test/java/SupplierTest.java b/java-8future/src/test/java/SupplierTest.java new file mode 100644 index 0000000..dfeae32 --- /dev/null +++ b/java-8future/src/test/java/SupplierTest.java @@ -0,0 +1,70 @@ +import org.junit.Test; + +import java.util.Optional; +import java.util.Random; +import java.util.function.Supplier; +import java.util.stream.Stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class SupplierTest { + /** + * Supplier接口测试，supplier相当一个容器或者变量，可以存储值 + */ + @Test + public void test_Supplier() { + //① 使用Supplier接口实现方法,只有一个get方法，无参数，返回一个值 + Supplier supplier = new Supplier() { + @Override + public Integer get() { + //返回一个随机值 + return new Random().nextInt(); + } + }; + + System.out.println(supplier.get()); + + System.out.println("********************"); + + //② 使用lambda表达式， + supplier = () -> new Random().nextInt(); + System.out.println(supplier.get()); + System.out.println("********************"); + + //③ 使用方法引用 + Supplier supplier2 = Math::random; + System.out.println(supplier2.get()); + } + + /** + * Supplier接口测试2，使用需要Supplier的接口方法 + */ + @Test + public void test_Supplier2() { + Stream stream = Stream.of(1, 2, 3, 4, 5); + //返回一个optional对象 + Optional first = stream.filter(i -> i > 4) + .findFirst(); + + //optional对象有需要Supplier接口的方法 + //orElse，如果first中存在数，就返回这个数，如果不存在，就放回传入的数 + System.out.println(first.orElse(1)); + System.out.println(first.orElse(7)); + + System.out.println("********************"); + + Supplier supplier = new Supplier() { + @Override + public Integer get() { + //返回一个随机值 + return new Random().nextInt(); + } + }; + + //orElseGet，如果first中存在数，就返回这个数，如果不存在，就返回supplier返回的值 + System.out.println(first.orElseGet(supplier)); + } +} diff --git a/java-8future/src/test/java/User.java b/java-8future/src/test/java/User.java new file mode 100644 index 0000000..cad3109 --- /dev/null +++ b/java-8future/src/test/java/User.java @@ -0,0 +1,8 @@ +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class User { + +} diff --git a/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/CollectionStreamGenerator.java b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/CollectionStreamGenerator.java new file mode 100644 index 0000000..41e8641 --- /dev/null +++ b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/CollectionStreamGenerator.java @@ -0,0 +1,47 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ + +import java.util.Iterator; +import java.util.List; + +/** + * 集合流生成器 + */ +public class CollectionStreamGenerator { + /** + * 将一个List转化为stream流 + * */ + public static MyStream getListStream(List list){ + return getListStream(list.iterator(),true); + } + + /** + * 递归函数 + * @param iterator list 集合的迭代器 + * @param isStart 是否是第一次迭代 + * */ + private static MyStream getListStream(Iterator iterator, boolean isStart){ + if(!iterator.hasNext()){ + // 不存在迭代的下一个元素，返回空的流 + return Stream.makeEmptyStream(); + } + + if(isStart){ + // 初始化，只需要设置 求值过程 + return new MyStream.Builder() + .nextItemEvalProcess(new NextItemEvalProcess(()-> getListStream(iterator,false))) + .build(); + }else{ + // 非初始化，设置head和接下来的求值过程 + return new MyStream.Builder() + .head(iterator.next()) + .nextItemEvalProcess(new NextItemEvalProcess(()-> getListStream(iterator,false))) + .build(); + } + } +} diff --git a/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/EvalFunction.java b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/EvalFunction.java new file mode 100644 index 0000000..ef0acae --- /dev/null +++ b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/EvalFunction.java @@ -0,0 +1,16 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +@FunctionalInterface +public interface EvalFunction { + + /** + * stream流的强制求值方法 + * @return 求值返回一个新的stream + * */ + MyStream apply(); +} diff --git a/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/ForEach.java b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/ForEach.java new file mode 100644 index 0000000..c3851f0 --- /dev/null +++ b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/ForEach.java @@ -0,0 +1,16 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +@FunctionalInterface +public interface ForEach { + + /** + * 迭代器遍历 + * @param item 被迭代的每一项 + * */ + void apply(T item); +} diff --git a/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/IntegerStreamGenerator.java b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/IntegerStreamGenerator.java new file mode 100644 index 0000000..76e47af --- /dev/null +++ b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/IntegerStreamGenerator.java @@ -0,0 +1,46 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ + +import java.util.stream.Stream; + +/** + * 整数流生成器 + */ +public class IntegerStreamGenerator { + /** + * 获得一个有限的整数流 介于[low-high]之间 + * @param low 下界 + * @param high 上界 + * */ + public static MyStream getIntegerStream(int low, int high){ + return getIntegerStreamInner(low,high,true); + } + + /** + * 递归函数。配合getIntegerStream(int low,int high) + * */ + private static MyStream getIntegerStreamInner(int low, int high, boolean isStart){ + if(low > high){ + // 到达边界条件，返回空的流 + return com.heks.stream.Stream.makeEmptyStream(); + } + + if(isStart){ + return new MyStream.Builder() + .nextItemEvalProcess(new NextItemEvalProcess(()->getIntegerStreamInner(low,high,false))) + .build(); + }else{ + return new MyStream.Builder() + // 当前元素 low + .head(low) + // 下一个元素 low+1 + .nextItemEvalProcess(new NextItemEvalProcess(()->getIntegerStreamInner(low+1,high,false))) + .build(); + } + } +} diff --git a/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/MyStream.java b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/MyStream.java new file mode 100644 index 0000000..1b08044 --- /dev/null +++ b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/MyStream.java @@ -0,0 +1,200 @@ +package com.heks.stream; + +import java.util.Comparator; +import java.util.Iterator; +import java.util.Optional; +import java.util.Spliterator; +import java.util.function.*; +import java.util.stream.Collector; + +/** + * @author heks + * @description: https://www.cnblogs.com/xiaoxiongcanguan/p/10511233.html + * + * 5.1 当前版本缺陷 + * 1. 递归调用效率较低 + * + * 　　为了代码的简洁性和更加的函数式，当前实现中很多地方都用递归代替了循环迭代。 + * + * 　　虽然逻辑上递归和迭代是等价的，但在目前的计算机硬件上，每一层的递归调用都会使得函数调用栈增大，而即使是明显的尾递归调用，java目前也没有能力进行优化。当流需要处理的数据量很大时，将会出现栈溢出，栈空间不足之类的系统错误。 + * + * 　　将递归优化为迭代能够显著提高当前版本流的执行效率。 + * + * 2. API接口较少 + * + * 　　限于篇幅，我们只提供了一些较为常用的API接口。在jdk中，Collector工具类提供了很多方便易用的接口；对于同一API接口也提供了多种重载函数给用户使用。 + * + * 　　以目前已有的功能为基础，提供一些更加方便的接口并不困难。 + * + * 3. 不支持并行计算 + * + * 　　由于流在求值计算时生成的是对象的副本，是无副作用的，很适合通过数据分片执行并行计算。限于个人水平，在设计之初并没有考虑将并行计算这一特性加入进来。 + * @date 2020/11/11 + */ +public class MyStream implements com.heks.stream.Stream { + /** + * 流的头部 + * */ + private T head; + + /** + * 流的下一项求值函数 + * */ + private NextItemEvalProcess nextItemEvalProcess; + + /** + * 是否是流的结尾 + * */ + private boolean isEnd; + + @Override + public MyStream map(Function mapper) { + NextItemEvalProcess lastNextItemEvalProcess = this.nextItemEvalProcess; + this.nextItemEvalProcess = new NextItemEvalProcess( + ()->{ + MyStream myStream = lastNextItemEvalProcess.eval(); + return map(mapper, myStream); + } + ); + + // 求值链条 加入一个新的process map + return new MyStream.Builder() + .nextItemEvalProcess(this.nextItemEvalProcess) + .build(); + } + /** + * 递归函数 配合API.map + * */ + private static MyStream map(Function mapper, MyStream myStream){ + if(myStream.isEmptyStream()){ + return Stream.makeEmptyStream(); + } + + T head = mapper.apply(myStream.head); + + return new MyStream.Builder() + .head((R) head) + .nextItemEvalProcess(new NextItemEvalProcess(()->map(mapper, myStream.eval()))) + .build(); + } + + @Override + public MyStream flatMap(Function, T> mapper) { + return null; + } + + @Override + public MyStream filter(Predicate predicate) { + return null; + } + + @Override + public MyStream limit(int n) { + return null; + } + + @Override + public MyStream distinct() { + return null; + } + + @Override + public MyStream peek(ForEach consumer) { + return null; + } + + @Override + public void forEach(ForEach consumer) { + // 终结操作 直接开始求值 + forEach(consumer,this.eval()); + } + + /** + * 递归函数 配合API.forEach + * */ + private static void forEach(ForEach consumer, MyStream myStream){ + if(myStream.isEmptyStream()){ + return; + } + + consumer.apply(myStream.head); + forEach(consumer, myStream.eval()); + } + + @Override + public R reduce(R initVal, BiFunction accumulator) { + return null; + } + + @Override + public R collect(Collector collector) { + return null; + } + + @Override + public T max(Comparator comparator) { + return null; + } + + @Override + public T min(Comparator comparator) { + return null; + } + + @Override + public int count() { + return 0; + } + + @Override + public boolean anyMatch(Predicate predicate) { + return false; + } + + @Override + public boolean allMatch(Predicate predicate) { + return false; + } + + public static class Builder{ + private MyStream target; + + public Builder() { + this.target = new MyStream<>(); + } + + public Builder head(T head){ + target.head = head; + return this; + } + + Builder isEnd(boolean isEnd){ + target.isEnd = isEnd; + return this; + } + + public Builder nextItemEvalProcess(NextItemEvalProcess nextItemEvalProcess){ + target.nextItemEvalProcess = nextItemEvalProcess; + return this; + } + + public MyStream build(){ + return target; + } + } + + /** + * 当前流强制求值 + * @return 求值之后返回一个新的流 + * */ + private MyStream eval(){ + return this.nextItemEvalProcess.eval(); + } + + /** + * 当前流 为空 + * */ + private boolean isEmptyStream(){ + return this.isEnd; + } +} diff --git a/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/NextItemEvalProcess.java b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/NextItemEvalProcess.java new file mode 100644 index 0000000..682bd25 --- /dev/null +++ b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/NextItemEvalProcess.java @@ -0,0 +1,25 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +/** + * 下一个元素求值过程 + */ +public class NextItemEvalProcess { + + /** + * 求值方法 + * */ + private EvalFunction evalFunction; + + public NextItemEvalProcess(EvalFunction evalFunction) { + this.evalFunction = evalFunction; + } + + MyStream eval(){ + return evalFunction.apply(); + } +} diff --git a/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/Person.java b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/Person.java new file mode 100644 index 0000000..5b0a0ac --- /dev/null +++ b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/Person.java @@ -0,0 +1,28 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class Person { + private int age; + + private String name; + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } +} diff --git a/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/Stream.java b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/Stream.java new file mode 100644 index 0000000..9cdedc5 --- /dev/null +++ b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/Stream.java @@ -0,0 +1,123 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ + +import java.util.Comparator; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.stream.Collector; + +/** + * stream流的API接口 + */ +public interface Stream { + + /** + * 映射 lazy 惰性求值 + * @param mapper 转换逻辑 T->R + * @return 一个新的流 + * */ + MyStream map(Function mapper); + + /** + * 扁平化 映射 lazy 惰性求值 + * @param mapper 转换逻辑 T->MyStream + * @return 一个新的流(扁平化之后) + * */ + MyStream flatMap(Function, T> mapper); + + /** + * 过滤 lazy 惰性求值 + * @param predicate 谓词判断 + * @return 一个新的流，其中元素是满足predicate条件的 + * */ + MyStream filter(Predicate predicate); + + /** + * 截断 lazy 惰性求值 + * @param n 截断流，只获取部分 + * @return 一个新的流，其中的元素不超过 n + * */ + MyStream limit(int n); + + /** + * 去重操作 lazy 惰性求值 + * @return 一个新的流，其中的元素不重复(!equals） + * */ + MyStream distinct(); + + /** + * 窥视 lazy 惰性求值 + * @return 同一个流，peek不改变流的任何行为 + * */ + MyStream peek(ForEach consumer); + + /** + * 遍历 eval 强制求值 + * @param consumer 遍历逻辑 + * */ + void forEach(ForEach consumer); + + /** + * 浓缩 eval 强制求值 + * @param initVal 浓缩时的初始值 + * @param accumulator 浓缩时的 累加逻辑 + * @return 浓缩之后的结果 + * */ + R reduce(R initVal, BiFunction accumulator); + + /** + * 收集 eval 强制求值 + * @param collector 传入所需的函数组合子，生成高阶函数 + * @return 收集之后的结果 + * */ + R collect(Collector collector); + + /** + * 最大值 eval 强制求值 + * @param comparator 大小比较逻辑 + * @return 流中的最大值 + * */ + T max(Comparator comparator); + + /** + * 最小值 eval 强制求值 + * @param comparator 大小比较逻辑 + * @return 流中的最小值 + * */ + T min(Comparator comparator); + + /** + * 计数 eval 强制求值 + * @return 当前流的个数 + * */ + int count(); + + /** + * 流中是否存在满足predicate的项 + * @return true 存在 匹配项 + * false 不存在 匹配项 + * */ + boolean anyMatch(Predicate predicate); + + /** + * 流中的元素是否全部满足predicate + * @return true 全部满足 + * false 不全部满足 + * */ + boolean allMatch(Predicate predicate); + + /** + * 返回空的 stream + * @return 空stream + * */ + static MyStream makeEmptyStream(){ + // isEnd = true + return new MyStream.Builder().isEnd(true).build(); + } +} diff --git a/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/StreamTest.java b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/StreamTest.java new file mode 100644 index 0000000..528c3b8 --- /dev/null +++ b/java-8stream/delombok/src-bak/src/main/java/com/heks/stream/StreamTest.java @@ -0,0 +1,42 @@ +package com.heks.stream; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collector; +import java.util.stream.Collectors; + +/** + * @author heks + * @description: 两种方案的不同之处： + * + * 　　从函数式的角度上看，过程式的代码实现将收集元素、循环迭代、各种逻辑判断耦合在一起，暴露了太多细节。当未来需求变动和变得更加复杂的情况下，过程式的代码将变得难以理解和维护(需要控制台打印出 年龄为70岁的前10个Person中，姓王的Person的名称）。 + * + * 　　函数式的解决方案解开了代码细节和业务逻辑的耦合，类似于sql语句，表达的是"要做什么"而不是"如何去做"，使程序员可以更加专注于业务逻辑，写出易于理解和维护的代码。 + * + * @FunctionalInterface 这个注解很有意思了 + * @date 2020/11/11 + */ +public class StreamTest { + public static void main(String[] args) { + List personList = new ArrayList(); // 获得List + int limit = 10; // 限制条件 + List nameList = new ArrayList(); // 收集的姓名集合 + for(Person personItem : personList){ + if(personItem.getAge() == 70){ // 满足条件 + nameList.add(personItem.getName()); // 加入姓名集合 + if(nameList.size() >= 10){ // 判断是否超过限制 + break; + } + } + } + System.out.println(nameList); + + System.out.println("************************"); + + List aa = personList.stream() + .filter(item->item.getAge() == 70)// 过滤条件 + .limit(10)// limit限制条件 + .map(item->item.getName())// 获得姓名 + .collect(Collectors.toList()); // 转化为list + } +} diff --git a/java-8stream/pom.xml b/java-8stream/pom.xml new file mode 100644 index 0000000..24666ea --- /dev/null +++ b/java-8stream/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + org.example + java-8stream + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/java-8stream/src/main/java/com/heks/stream/CollectionStreamGenerator.java b/java-8stream/src/main/java/com/heks/stream/CollectionStreamGenerator.java new file mode 100644 index 0000000..41e8641 --- /dev/null +++ b/java-8stream/src/main/java/com/heks/stream/CollectionStreamGenerator.java @@ -0,0 +1,47 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ + +import java.util.Iterator; +import java.util.List; + +/** + * 集合流生成器 + */ +public class CollectionStreamGenerator { + /** + * 将一个List转化为stream流 + * */ + public static MyStream getListStream(List list){ + return getListStream(list.iterator(),true); + } + + /** + * 递归函数 + * @param iterator list 集合的迭代器 + * @param isStart 是否是第一次迭代 + * */ + private static MyStream getListStream(Iterator iterator, boolean isStart){ + if(!iterator.hasNext()){ + // 不存在迭代的下一个元素，返回空的流 + return Stream.makeEmptyStream(); + } + + if(isStart){ + // 初始化，只需要设置 求值过程 + return new MyStream.Builder() + .nextItemEvalProcess(new NextItemEvalProcess(()-> getListStream(iterator,false))) + .build(); + }else{ + // 非初始化，设置head和接下来的求值过程 + return new MyStream.Builder() + .head(iterator.next()) + .nextItemEvalProcess(new NextItemEvalProcess(()-> getListStream(iterator,false))) + .build(); + } + } +} diff --git a/java-8stream/src/main/java/com/heks/stream/EvalFunction.java b/java-8stream/src/main/java/com/heks/stream/EvalFunction.java new file mode 100644 index 0000000..ef0acae --- /dev/null +++ b/java-8stream/src/main/java/com/heks/stream/EvalFunction.java @@ -0,0 +1,16 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +@FunctionalInterface +public interface EvalFunction { + + /** + * stream流的强制求值方法 + * @return 求值返回一个新的stream + * */ + MyStream apply(); +} diff --git a/java-8stream/src/main/java/com/heks/stream/ForEach.java b/java-8stream/src/main/java/com/heks/stream/ForEach.java new file mode 100644 index 0000000..c3851f0 --- /dev/null +++ b/java-8stream/src/main/java/com/heks/stream/ForEach.java @@ -0,0 +1,16 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +@FunctionalInterface +public interface ForEach { + + /** + * 迭代器遍历 + * @param item 被迭代的每一项 + * */ + void apply(T item); +} diff --git a/java-8stream/src/main/java/com/heks/stream/IntegerStreamGenerator.java b/java-8stream/src/main/java/com/heks/stream/IntegerStreamGenerator.java new file mode 100644 index 0000000..76e47af --- /dev/null +++ b/java-8stream/src/main/java/com/heks/stream/IntegerStreamGenerator.java @@ -0,0 +1,46 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ + +import java.util.stream.Stream; + +/** + * 整数流生成器 + */ +public class IntegerStreamGenerator { + /** + * 获得一个有限的整数流 介于[low-high]之间 + * @param low 下界 + * @param high 上界 + * */ + public static MyStream getIntegerStream(int low, int high){ + return getIntegerStreamInner(low,high,true); + } + + /** + * 递归函数。配合getIntegerStream(int low,int high) + * */ + private static MyStream getIntegerStreamInner(int low, int high, boolean isStart){ + if(low > high){ + // 到达边界条件，返回空的流 + return com.heks.stream.Stream.makeEmptyStream(); + } + + if(isStart){ + return new MyStream.Builder() + .nextItemEvalProcess(new NextItemEvalProcess(()->getIntegerStreamInner(low,high,false))) + .build(); + }else{ + return new MyStream.Builder() + // 当前元素 low + .head(low) + // 下一个元素 low+1 + .nextItemEvalProcess(new NextItemEvalProcess(()->getIntegerStreamInner(low+1,high,false))) + .build(); + } + } +} diff --git a/java-8stream/src/main/java/com/heks/stream/MyStream.java b/java-8stream/src/main/java/com/heks/stream/MyStream.java new file mode 100644 index 0000000..1b08044 --- /dev/null +++ b/java-8stream/src/main/java/com/heks/stream/MyStream.java @@ -0,0 +1,200 @@ +package com.heks.stream; + +import java.util.Comparator; +import java.util.Iterator; +import java.util.Optional; +import java.util.Spliterator; +import java.util.function.*; +import java.util.stream.Collector; + +/** + * @author heks + * @description: https://www.cnblogs.com/xiaoxiongcanguan/p/10511233.html + * + * 5.1 当前版本缺陷 + * 1. 递归调用效率较低 + * + * 　　为了代码的简洁性和更加的函数式，当前实现中很多地方都用递归代替了循环迭代。 + * + * 　　虽然逻辑上递归和迭代是等价的，但在目前的计算机硬件上，每一层的递归调用都会使得函数调用栈增大，而即使是明显的尾递归调用，java目前也没有能力进行优化。当流需要处理的数据量很大时，将会出现栈溢出，栈空间不足之类的系统错误。 + * + * 　　将递归优化为迭代能够显著提高当前版本流的执行效率。 + * + * 2. API接口较少 + * + * 　　限于篇幅，我们只提供了一些较为常用的API接口。在jdk中，Collector工具类提供了很多方便易用的接口；对于同一API接口也提供了多种重载函数给用户使用。 + * + * 　　以目前已有的功能为基础，提供一些更加方便的接口并不困难。 + * + * 3. 不支持并行计算 + * + * 　　由于流在求值计算时生成的是对象的副本，是无副作用的，很适合通过数据分片执行并行计算。限于个人水平，在设计之初并没有考虑将并行计算这一特性加入进来。 + * @date 2020/11/11 + */ +public class MyStream implements com.heks.stream.Stream { + /** + * 流的头部 + * */ + private T head; + + /** + * 流的下一项求值函数 + * */ + private NextItemEvalProcess nextItemEvalProcess; + + /** + * 是否是流的结尾 + * */ + private boolean isEnd; + + @Override + public MyStream map(Function mapper) { + NextItemEvalProcess lastNextItemEvalProcess = this.nextItemEvalProcess; + this.nextItemEvalProcess = new NextItemEvalProcess( + ()->{ + MyStream myStream = lastNextItemEvalProcess.eval(); + return map(mapper, myStream); + } + ); + + // 求值链条 加入一个新的process map + return new MyStream.Builder() + .nextItemEvalProcess(this.nextItemEvalProcess) + .build(); + } + /** + * 递归函数 配合API.map + * */ + private static MyStream map(Function mapper, MyStream myStream){ + if(myStream.isEmptyStream()){ + return Stream.makeEmptyStream(); + } + + T head = mapper.apply(myStream.head); + + return new MyStream.Builder() + .head((R) head) + .nextItemEvalProcess(new NextItemEvalProcess(()->map(mapper, myStream.eval()))) + .build(); + } + + @Override + public MyStream flatMap(Function, T> mapper) { + return null; + } + + @Override + public MyStream filter(Predicate predicate) { + return null; + } + + @Override + public MyStream limit(int n) { + return null; + } + + @Override + public MyStream distinct() { + return null; + } + + @Override + public MyStream peek(ForEach consumer) { + return null; + } + + @Override + public void forEach(ForEach consumer) { + // 终结操作 直接开始求值 + forEach(consumer,this.eval()); + } + + /** + * 递归函数 配合API.forEach + * */ + private static void forEach(ForEach consumer, MyStream myStream){ + if(myStream.isEmptyStream()){ + return; + } + + consumer.apply(myStream.head); + forEach(consumer, myStream.eval()); + } + + @Override + public R reduce(R initVal, BiFunction accumulator) { + return null; + } + + @Override + public R collect(Collector collector) { + return null; + } + + @Override + public T max(Comparator comparator) { + return null; + } + + @Override + public T min(Comparator comparator) { + return null; + } + + @Override + public int count() { + return 0; + } + + @Override + public boolean anyMatch(Predicate predicate) { + return false; + } + + @Override + public boolean allMatch(Predicate predicate) { + return false; + } + + public static class Builder{ + private MyStream target; + + public Builder() { + this.target = new MyStream<>(); + } + + public Builder head(T head){ + target.head = head; + return this; + } + + Builder isEnd(boolean isEnd){ + target.isEnd = isEnd; + return this; + } + + public Builder nextItemEvalProcess(NextItemEvalProcess nextItemEvalProcess){ + target.nextItemEvalProcess = nextItemEvalProcess; + return this; + } + + public MyStream build(){ + return target; + } + } + + /** + * 当前流强制求值 + * @return 求值之后返回一个新的流 + * */ + private MyStream eval(){ + return this.nextItemEvalProcess.eval(); + } + + /** + * 当前流 为空 + * */ + private boolean isEmptyStream(){ + return this.isEnd; + } +} diff --git a/java-8stream/src/main/java/com/heks/stream/NextItemEvalProcess.java b/java-8stream/src/main/java/com/heks/stream/NextItemEvalProcess.java new file mode 100644 index 0000000..682bd25 --- /dev/null +++ b/java-8stream/src/main/java/com/heks/stream/NextItemEvalProcess.java @@ -0,0 +1,25 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +/** + * 下一个元素求值过程 + */ +public class NextItemEvalProcess { + + /** + * 求值方法 + * */ + private EvalFunction evalFunction; + + public NextItemEvalProcess(EvalFunction evalFunction) { + this.evalFunction = evalFunction; + } + + MyStream eval(){ + return evalFunction.apply(); + } +} diff --git a/java-8stream/src/main/java/com/heks/stream/Person.java b/java-8stream/src/main/java/com/heks/stream/Person.java new file mode 100644 index 0000000..5b0a0ac --- /dev/null +++ b/java-8stream/src/main/java/com/heks/stream/Person.java @@ -0,0 +1,28 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ +public class Person { + private int age; + + private String name; + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } +} diff --git a/java-8stream/src/main/java/com/heks/stream/Stream.java b/java-8stream/src/main/java/com/heks/stream/Stream.java new file mode 100644 index 0000000..9cdedc5 --- /dev/null +++ b/java-8stream/src/main/java/com/heks/stream/Stream.java @@ -0,0 +1,123 @@ +package com.heks.stream; + +/** + * @author heks + * @description: TODO + * @date 2020/11/11 + */ + +import java.util.Comparator; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.stream.Collector; + +/** + * stream流的API接口 + */ +public interface Stream { + + /** + * 映射 lazy 惰性求值 + * @param mapper 转换逻辑 T->R + * @return 一个新的流 + * */ + MyStream map(Function mapper); + + /** + * 扁平化 映射 lazy 惰性求值 + * @param mapper 转换逻辑 T->MyStream + * @return 一个新的流(扁平化之后) + * */ + MyStream flatMap(Function, T> mapper); + + /** + * 过滤 lazy 惰性求值 + * @param predicate 谓词判断 + * @return 一个新的流，其中元素是满足predicate条件的 + * */ + MyStream filter(Predicate predicate); + + /** + * 截断 lazy 惰性求值 + * @param n 截断流，只获取部分 + * @return 一个新的流，其中的元素不超过 n + * */ + MyStream limit(int n); + + /** + * 去重操作 lazy 惰性求值 + * @return 一个新的流，其中的元素不重复(!equals） + * */ + MyStream distinct(); + + /** + * 窥视 lazy 惰性求值 + * @return 同一个流，peek不改变流的任何行为 + * */ + MyStream peek(ForEach consumer); + + /** + * 遍历 eval 强制求值 + * @param consumer 遍历逻辑 + * */ + void forEach(ForEach consumer); + + /** + * 浓缩 eval 强制求值 + * @param initVal 浓缩时的初始值 + * @param accumulator 浓缩时的 累加逻辑 + * @return 浓缩之后的结果 + * */ + R reduce(R initVal, BiFunction accumulator); + + /** + * 收集 eval 强制求值 + * @param collector 传入所需的函数组合子，生成高阶函数 + * @return 收集之后的结果 + * */ + R collect(Collector collector); + + /** + * 最大值 eval 强制求值 + * @param comparator 大小比较逻辑 + * @return 流中的最大值 + * */ + T max(Comparator comparator); + + /** + * 最小值 eval 强制求值 + * @param comparator 大小比较逻辑 + * @return 流中的最小值 + * */ + T min(Comparator comparator); + + /** + * 计数 eval 强制求值 + * @return 当前流的个数 + * */ + int count(); + + /** + * 流中是否存在满足predicate的项 + * @return true 存在 匹配项 + * false 不存在 匹配项 + * */ + boolean anyMatch(Predicate predicate); + + /** + * 流中的元素是否全部满足predicate + * @return true 全部满足 + * false 不全部满足 + * */ + boolean allMatch(Predicate predicate); + + /** + * 返回空的 stream + * @return 空stream + * */ + static MyStream makeEmptyStream(){ + // isEnd = true + return new MyStream.Builder().isEnd(true).build(); + } +} diff --git a/java-8stream/src/main/java/com/heks/stream/StreamTest.java b/java-8stream/src/main/java/com/heks/stream/StreamTest.java new file mode 100644 index 0000000..528c3b8 --- /dev/null +++ b/java-8stream/src/main/java/com/heks/stream/StreamTest.java @@ -0,0 +1,42 @@ +package com.heks.stream; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collector; +import java.util.stream.Collectors; + +/** + * @author heks + * @description: 两种方案的不同之处： + * + * 　　从函数式的角度上看，过程式的代码实现将收集元素、循环迭代、各种逻辑判断耦合在一起，暴露了太多细节。当未来需求变动和变得更加复杂的情况下，过程式的代码将变得难以理解和维护(需要控制台打印出 年龄为70岁的前10个Person中，姓王的Person的名称）。 + * + * 　　函数式的解决方案解开了代码细节和业务逻辑的耦合，类似于sql语句，表达的是"要做什么"而不是"如何去做"，使程序员可以更加专注于业务逻辑，写出易于理解和维护的代码。 + * + * @FunctionalInterface 这个注解很有意思了 + * @date 2020/11/11 + */ +public class StreamTest { + public static void main(String[] args) { + List personList = new ArrayList(); // 获得List + int limit = 10; // 限制条件 + List nameList = new ArrayList(); // 收集的姓名集合 + for(Person personItem : personList){ + if(personItem.getAge() == 70){ // 满足条件 + nameList.add(personItem.getName()); // 加入姓名集合 + if(nameList.size() >= 10){ // 判断是否超过限制 + break; + } + } + } + System.out.println(nameList); + + System.out.println("************************"); + + List aa = personList.stream() + .filter(item->item.getAge() == 70)// 过滤条件 + .limit(10)// limit限制条件 + .map(item->item.getName())// 获得姓名 + .collect(Collectors.toList()); // 转化为list + } +} diff --git a/java-agent/delombok/src-bak/src/main/java/com/hks/agent/AgentMain.java b/java-agent/delombok/src-bak/src/main/java/com/hks/agent/AgentMain.java new file mode 100644 index 0000000..10c632d --- /dev/null +++ b/java-agent/delombok/src-bak/src/main/java/com/hks/agent/AgentMain.java @@ -0,0 +1,65 @@ +package com.hks.agent; + +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import java.lang.instrument.ClassFileTransformer; +import java.lang.instrument.IllegalClassFormatException; +import java.lang.instrument.Instrumentation; +import java.security.ProtectionDomain; +/** + * Description: + * + * @author hekuangsheng + * @version 1.0 + * @since 2019-04-15 + */ +public class AgentMain { + public static void premain(String agentOps, Instrumentation inst) { + instrument(agentOps, inst); + } + public static void agentmain(String agentOps, Instrumentation inst) { + instrument(agentOps, inst); + } + private static void instrument(String agentOps, Instrumentation inst) { + System.out.println(agentOps); + inst.addTransformer(new ClassFileTransformer() { + @Override + public byte[] transform(ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException { + return transformClass(loader, className, classBeingRedefined, protectionDomain, classfileBuffer); + } + }); + System.out.println(inst); + } + private static byte[] transformClass(ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) { + System.out.println("Transform loader " + loader + " className: " + className + " classBeingRedefined " + classBeingRedefined); + ClassReader classReader = new ClassReader(classfileBuffer); + ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES); + classReader.accept(new MyClassClassVisitor(classWriter), 0); + byte[] bytes = classWriter.toByteArray(); + return bytes; + } + static class MyClassClassVisitor extends ClassVisitor { + public MyClassClassVisitor(ClassVisitor cv) { + super(Opcodes.ASM5, cv); + } + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] + exceptions) { + System.out.println("visit " + name + " desc " + desc); + if ("say".equals(name)) { + // do call + MethodVisitor methodVisitor = cv.visitMethod(access, name, desc, signature, exceptions); + methodVisitor.visitCode(); + methodVisitor.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); + methodVisitor.visitLdcInsn("CALL " + name); + methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false); + methodVisitor.visitEnd(); + return methodVisitor; + } + return super.visitMethod(access, name, desc, signature, exceptions); + } + } +} diff --git a/java-agent/delombok/src-bak/src/main/resources/META-INF/MANIFEST.MF b/java-agent/delombok/src-bak/src/main/resources/META-INF/MANIFEST.MF new file mode 100644 index 0000000..cddf113 --- /dev/null +++ b/java-agent/delombok/src-bak/src/main/resources/META-INF/MANIFEST.MF @@ -0,0 +1,4 @@ +Manifest-Version: 1.0 +Premain-Class: com.hks.agent.AgentMain +Agent-Class: com.hks.agent.AgentMain +Can-Redefine-Classes: true diff --git a/java-agent/delombok/src-bak/src/test/java/TestJVM.java b/java-agent/delombok/src-bak/src/test/java/TestJVM.java new file mode 100644 index 0000000..2f19ec9 --- /dev/null +++ b/java-agent/delombok/src-bak/src/test/java/TestJVM.java @@ -0,0 +1,9 @@ +public class TestJVM { + public static void main(String[] args) { + TestJVM testJVM = new TestJVM(); + testJVM.say(); + } + public void say() { + System.out.println("Say Hello"); + } +} \ No newline at end of file diff --git a/java-agent/target/classes/com/hks/agent/AgentMain$1.class b/java-agent/target/classes/com/hks/agent/AgentMain$1.class deleted file mode 100644 index 1d6b384..0000000 Binary files a/java-agent/target/classes/com/hks/agent/AgentMain$1.class and /dev/null differ diff --git a/java-agent/target/classes/com/hks/agent/AgentMain$MyClassClassVisitor.class b/java-agent/target/classes/com/hks/agent/AgentMain$MyClassClassVisitor.class deleted file mode 100644 index d2a0b21..0000000 Binary files a/java-agent/target/classes/com/hks/agent/AgentMain$MyClassClassVisitor.class and /dev/null differ diff --git a/java-agent/target/classes/com/hks/agent/AgentMain.class b/java-agent/target/classes/com/hks/agent/AgentMain.class deleted file mode 100644 index dad7e97..0000000 Binary files a/java-agent/target/classes/com/hks/agent/AgentMain.class and /dev/null differ diff --git a/java-agent/target/test-classes/TestJVM.class b/java-agent/target/test-classes/TestJVM.class deleted file mode 100644 index c0a85bf..0000000 Binary files a/java-agent/target/test-classes/TestJVM.class and /dev/null differ diff --git a/java-algorithms/pom.xml b/java-algorithms/pom.xml index ee03df0..b07b85d 100644 --- a/java-algorithms/pom.xml +++ b/java-algorithms/pom.xml @@ -36,6 +36,12 @@ 2.0.4.RELEASE + + org.springframework.boot + spring-boot-starter-web + 2.0.4.RELEASE + + io.springfox springfox-swagger2 diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/DuplicateZeros.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/DuplicateZeros.java new file mode 100644 index 0000000..7726ef0 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/DuplicateZeros.java @@ -0,0 +1,29 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class DuplicateZeros { + + public void duplicateZeros(int[] arr) { + int zeroNum = 0; + int arrLen = arr.length - 1; + for (int i = 0; i <= arrLen - zeroNum; i++) { + if (arr[i] == 0) { + if (i == arrLen - zeroNum) { + arr[arrLen] = 0; + arrLen = arrLen - 1; + break; + } + zeroNum++; + } + } + + for (int i = arrLen; i >= 0; i--) { + if (arr[i] == 0) { + arr[i + zeroNum] = 0; + zeroNum--; + arr[i + zeroNum] = 0; + } else { + arr[i + zeroNum] = arr[i]; + } + } + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/LRUCache.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/LRUCache.java new file mode 100644 index 0000000..1df5b79 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/LRUCache.java @@ -0,0 +1,4 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class LRUCache { +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/ReverseWords.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/ReverseWords.java new file mode 100644 index 0000000..71990ea --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/ReverseWords.java @@ -0,0 +1,68 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import com.sun.jmx.remote.internal.ArrayQueue; + +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.Queue; + +public class ReverseWords { + + public static void main(String[] args) { + String s = "the sky is blue"; + String ss = reverseWords(s); + System.out.println(ss); + } + + public static String reverseWords(String s) { + int left = 0, right = s.length() - 1; + while (left <= right && s.charAt(right) == ' ') { + right--; + } + while (left <= right && s.charAt(left) == ' ') { + left++; + } + Deque queue = new ArrayDeque<>(); + StringBuilder sb = new StringBuilder(); + while (left <= right) { + if (sb.length() != 0 && s.charAt(left) == ' ') { + queue.addFirst(sb.toString()); + sb.setLength(0); + } + if (s.charAt(left) != ' ') { + sb.append(s.charAt(left)); + } + left++; + } + queue.addFirst(sb.toString()); + return String.join(" ", queue); + /*int left = 0, right = s.length() - 1; + // 去掉字符串开头的空白字符 + while (left <= right && s.charAt(left) == ' ') { + ++left; + } + + // 去掉字符串末尾的空白字符 + while (left <= right && s.charAt(right) == ' ') { + --right; + } + + Deque d = new ArrayDeque(); + StringBuilder word = new StringBuilder(); + + while (left <= right) { + char c = s.charAt(left); + if ((word.length() != 0) && (c == ' ')) { + // 将单词 push 到队列的头部 + d.offerFirst(word.toString()); + word.setLength(0); + } else if (c != ' ') { + word.append(c); + } + ++left; + } + d.offerFirst(word.toString()); + + return String.join(" ", d);*/ + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/TwoSum.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/TwoSum.java index 123cd6c..a4bdded 100644 --- a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/TwoSum.java +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/TwoSum.java @@ -1,13 +1,9 @@ package com.hks.eightsortingalgorithms.leetcode; -import org.junit.jupiter.api.Test; import java.util.HashMap; import java.util.Map; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; - /** * @Author: hekuangsheng * @Date: 2018/10/25 @@ -21,24 +17,22 @@ */ public class TwoSum { - int[] nums = {2, 7, 11, 15}; - int target = 9; - int[] except = {0, 1}; + public static void main(String[] args) { + int[] nums = {2, 7, 11, 15}; + int target = 9; + int[] except = {0, 1}; + int[] ii = twoSum(nums, 9); + } - public int[] twoSum(int[] nums, int target) { + public static int[] twoSum(int[] nums, int target) { Map map = new HashMap<>(); - for (int i = 0; i < nums.length; i++) { - int complement = target - nums[i]; - if (map.containsKey(complement)) { - return new int[]{map.get(complement), i}; + for(int i=0; i averageOfLevels(TreeNode root) { + List res = new ArrayList<>(); + Queue dq = new LinkedList<>(); + dq.offer(root); + + while(!dq.isEmpty()) { + int size = dq.size(); + double levelSum = 0; + for (int i = 0; i < size; i++) { + TreeNode node = dq.poll(); + levelSum += node.val; + if(node.left != null) { + dq.offer(node.left); + } + if(node.right != null) { + dq.offer(node.right); + } + } + res.add(1.0 * levelSum / size); + } + return res; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/binaryTreePaths.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/binaryTreePaths.java new file mode 100644 index 0000000..8abcab3 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/binaryTreePaths.java @@ -0,0 +1,52 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; +import java.util.List; + +public class binaryTreePaths { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public List binaryTreePaths(TreeNode root) { + // 遍历一遍二叉树就能出结果了 + traverse(root); + return res; + } + + // 记录 traverse 函数递归时的路径 + LinkedList path = new LinkedList<>(); + // 记录所有从根节点到叶子节点的路径 + LinkedList res = new LinkedList<>(); + + void traverse(TreeNode root) { + if(root == null) { + return; + } + if(root.left == null && root.right == null) { + path.addLast(root.val + ""); + res.add(String.join("->", path)); + path.removeLast(); + } + path.addLast(root.val + ""); + traverse(root.left); + traverse(root.right); + path.removeLast(); + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/bstFromPreorder.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/bstFromPreorder.java new file mode 100644 index 0000000..8f61b51 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/bstFromPreorder.java @@ -0,0 +1,42 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class bstFromPreorder { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public TreeNode bstFromPreorder(int[] preorder) { + return build(preorder, 0, preorder.length - 1); + } + + // 定义：将 preorder[start..end] 区间内的元素生成 BST，并返回根节点 + private TreeNode build(int[] preorder, int start, int end) { + if(start > end) { + return null; + } + int rootVal = preorder[start]; + TreeNode root = new TreeNode(rootVal); + int index = start + 1; + while(index < end && preorder[index] < rootVal) { + index++; + } + root.left = build(preorder, start+1, index-1); + root.right = build(preorder, index, end); + return root; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/buildTreeAfter.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/buildTreeAfter.java new file mode 100644 index 0000000..be35193 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/buildTreeAfter.java @@ -0,0 +1,62 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class buildTreeAfter { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public TreeNode buildTree(int[] inorder, int[] postorder) { + return build(inorder, 0, inorder.length - 1, + postorder, 0, postorder.length - 1); + } + + /* + 定义： + 中序遍历数组为 inorder[inStart..inEnd]， + 后序遍历数组为 postorder[postStart..postEnd]， + 构造这个二叉树并返回该二叉树的根节点 + */ + TreeNode build(int[] inorder, int inStart, int inEnd, + int[] postorder, int postStart, int postEnd) { + + if (inStart > inEnd) { + return null; + } + // root 节点对应的值就是后序遍历数组的最后一个元素 + int rootVal = postorder[postEnd]; + // rootVal 在中序遍历数组中的索引 + int index = 0; + for (int i = inStart; i <= inEnd; i++) { + if (inorder[i] == rootVal) { + index = i; + break; + } + } + // 左子树的节点个数 + int leftSize = index - inStart; + TreeNode root = new TreeNode(rootVal); + // 递归构造左右子树 + root.left = build(inorder, inStart, index - 1, + postorder, postStart, postStart + leftSize - 1); + + root.right = build(inorder, index + 1, inEnd, + postorder, postStart + leftSize, postEnd - 1); + return root; + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/buildTreePre.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/buildTreePre.java new file mode 100644 index 0000000..0ca4458 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/buildTreePre.java @@ -0,0 +1,50 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class buildTreePre { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public TreeNode buildTree(int[] preorder, int[] inorder) { + if (preorder == null || inorder == null || preorder.length == 0 || inorder.length == 0) { + return null; + } + return build(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1); + } + + TreeNode build(int[] preorder, int preStart, int preEnd, + int[] inorder, int inStart, int inEnd) { + if (preStart > preEnd) { + return null; + } + int rootVal = preorder[preStart]; + int index = 0; + for (int i = inStart; i <= inEnd; i++) { + if (inorder[i] == rootVal) { + index = i; + break; + } + } + + TreeNode root = new TreeNode(rootVal); + int leftSize = index - inStart; + root.left = build(preorder, preStart + 1, preStart + leftSize, inorder, inStart, index - 1); + root.right = build(preorder, preStart + leftSize + 1, preEnd, inorder, index + 1, inEnd); + return root; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/coinChange.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/coinChange.java new file mode 100644 index 0000000..a989b46 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/coinChange.java @@ -0,0 +1,19 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.Arrays; + +public class coinChange { + public int coinChange(int[] coins, int amount) { + int[] dp = new int[amount + 1]; + Arrays.fill(dp, amount + 1); + dp[0] = 0; + for (int i = 1; i <= amount; i++) { + for (int j = 0; j < coins.length; j++) { + if (coins[i] <= i) { + dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1); + } + } + } + return (dp[amount] > amount) ? -1 : dp[amount]; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/combinationSum.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/combinationSum.java new file mode 100644 index 0000000..bb93fa5 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/combinationSum.java @@ -0,0 +1,46 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; +import java.util.List; + +public class combinationSum { + List> res = new LinkedList<>(); + // 记录回溯的路径 + LinkedList track = new LinkedList<>(); + // 记录 track 中的路径和 + int trackSum = 0; + + public List> combinationSum(int[] candidates, int target) { + if (candidates.length == 0) { + return res; + } + backtrack(candidates, 0, target); + return res; + } + + // 回溯算法主函数 + void backtrack(int[] nums, int start, int target) { + // base case，找到目标和，记录结果 + if (trackSum == target) { + res.add(new LinkedList<>(track)); + return; + } + // base case，超过目标和，停止向下遍历 + if (trackSum > target) { + return; + } + + // 回溯算法标准框架 + for (int i = start; i < nums.length; i++) { + // 选择 nums[i] + trackSum += nums[i]; + track.add(nums[i]); + // 递归遍历下一层回溯树 + // 同一元素可重复使用，注意参数 + backtrack(nums, i, target); + // 撤销选择 nums[i] + trackSum -= nums[i]; + track.removeLast(); + } + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/combinationSum2.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/combinationSum2.java new file mode 100644 index 0000000..48c284b --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/combinationSum2.java @@ -0,0 +1,53 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.Arrays; +import java.util.LinkedList; +import java.util.List; + +public class combinationSum2 { + List> res = new LinkedList<>(); + // 记录回溯的路径 + LinkedList track = new LinkedList<>(); + // 记录 track 中的元素之和 + int trackSum = 0; + + public List> combinationSum2(int[] candidates, int target) { + if (candidates.length == 0) { + return res; + } + // 先排序，让相同的元素靠在一起 + Arrays.sort(candidates); + backtrack(candidates, 0, target); + return res; + } + + // 回溯算法主函数 + void backtrack(int[] nums, int start, int target) { + // base case，达到目标和，找到符合条件的组合 + if (trackSum == target) { + res.add(new LinkedList<>(track)); + return; + } + // base case，超过目标和，直接结束 + if (trackSum > target) { + return; + } + + // 回溯算法标准框架 + for (int i = start; i < nums.length; i++) { + // 剪枝逻辑，值相同的树枝，只遍历第一条 + if (i > start && nums[i] == nums[i - 1]) { + continue; + } + // 做选择 + track.add(nums[i]); + trackSum += nums[i]; + // 递归遍历下一层回溯树 + backtrack(nums, i + 1, target); + // 撤销选择 + track.removeLast(); + trackSum -= nums[i]; + } + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/combine.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/combine.java new file mode 100644 index 0000000..45658fd --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/combine.java @@ -0,0 +1,36 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; +import java.util.List; + +public class combine { + List> res = new LinkedList<>(); + // 记录回溯算法的递归路径 + LinkedList track = new LinkedList<>(); + + // 主函数 + public List> combine(int n, int k) { + backtrack(1, n, k); + return res; + } + + void backtrack(int start, int n, int k) { + // base case + if (k == track.size()) { + // 遍历到了第 k 层，收集当前节点的值 + res.add(new LinkedList<>(track)); + return; + } + + // 回溯算法标准框架 + for (int i = start; i <= n; i++) { + // 选择 + track.addLast(i); + // 通过 start 参数控制树枝的遍历，避免产生重复的子集 + backtrack(i + 1, n, k); + // 撤销选择 + track.removeLast(); + } + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/constructMaximumBinaryTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/constructMaximumBinaryTree.java new file mode 100644 index 0000000..6457fed --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/constructMaximumBinaryTree.java @@ -0,0 +1,49 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class constructMaximumBinaryTree { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public TreeNode constructMaximumBinaryTree(int[] nums) { + if(nums==null||nums.length==0) { + return null; + } + if(nums.length==1){ + return new TreeNode(nums[0]); + } + return dfs(nums, 0, nums.length-1); + } + + TreeNode dfs(int[] nums, int left, int right) { + if(left > right) { + return null; + } + int index = -1, max = Integer.MIN_VALUE; + for (int i = left; i <= right; i++) { + if(nums[i] > max) { + max = nums[i]; + index = i; + } + } + TreeNode root = new TreeNode(max); + root.left = dfs(nums, left, index-1); + root.right = dfs(nums, index+1, right); + return root; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/convertToTitle.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/convertToTitle.java new file mode 100644 index 0000000..5655c19 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/convertToTitle.java @@ -0,0 +1,20 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class convertToTitle { + + public static void main(String[] args) { + String s = convertToTitle(77); + System.out.println(s); + } + + public static String convertToTitle(int cn) { + StringBuilder sb = new StringBuilder(); + while(cn>0) { + cn--; + sb.append((char)(cn%26 + 'A')); + cn = cn /26; + } + sb.reverse(); + return sb.toString(); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/countNodes.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/countNodes.java new file mode 100644 index 0000000..8840393 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/countNodes.java @@ -0,0 +1,42 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class countNodes { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public int countNodes(TreeNode root) { + TreeNode l = root, r = root; + // 记录左、右子树的高度 + int hl = 0, hr = 0; + while (l != null) { + l = l.left; + hl++; + } + while (r != null) { + r = r.right; + hr++; + } + // 如果左右子树的高度相同，则是一棵满二叉树 + if (hl == hr) { + return (int) Math.pow(2, hl) - 1; + } + // 如果左右高度不同，则按照普通二叉树的逻辑计算 + return 1 + countNodes(root.left) + countNodes(root.right); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/deleteDuplicates.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/deleteDuplicates.java new file mode 100644 index 0000000..0fe9f36 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/deleteDuplicates.java @@ -0,0 +1,35 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import org.aspectj.weaver.loadtime.definition.Definition; + +public class deleteDuplicates { + + public static void main(String[] args) { + + } + // [1,1,2,3,3] + public class ListNode { + int val; + ListNode next; + ListNode() {} + ListNode(int val) { this.val = val; } + ListNode(int val, ListNode next) { this.val = val; this.next = next; } + } + + public ListNode deleteDuplicates(ListNode head) { + if (head == null) { + return head; + } + + ListNode cur = head; + while (cur.next != null) { + if (cur.val == cur.next.val) { + cur.next = cur.next.next; + } else { + cur = cur.next; + } + } + + return head; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/detectCycle.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/detectCycle.java new file mode 100644 index 0000000..6c2487c --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/detectCycle.java @@ -0,0 +1,35 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class detectCycle { + class ListNode { + int val; + ListNode next; + + ListNode(int x) { + val = x; + next = null; + } + } + + public ListNode detectCycle(ListNode head) { + ListNode fast, slow; + fast = slow = head; + while (fast != null && fast.next != null) { + fast = fast.next.next; + slow = slow.next; + if (fast == slow) break; + } + // 上面的代码类似 hasCycle 函数 + if (fast == null || fast.next == null) { + // fast 遇到空指针说明没有环 + return null; + } + + slow = head; + while (slow != fast) { + fast = fast.next; + slow = slow.next; + } + return slow; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/diameterOfBinaryTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/diameterOfBinaryTree.java new file mode 100644 index 0000000..059fdfd --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/diameterOfBinaryTree.java @@ -0,0 +1,36 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class diameterOfBinaryTree { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + TreeNode() {} + TreeNode(int val) { this.val = val; } + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + // 记录最大直径的长度 + int maxDiameter = 0; + + public int diameterOfBinaryTree(TreeNode root) { + maxDepth(root); + return maxDiameter; + } + + int maxDepth(TreeNode root) { + if(root==null) { + return 0; + } + int left = maxDepth(root.left); + int right = maxDepth(root.right); + int max = left + right; + maxDiameter = Math.max(max, maxDiameter); + + return 1+Math.max(left,right); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/distanceK.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/distanceK.java new file mode 100644 index 0000000..951e966 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/distanceK.java @@ -0,0 +1,79 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.*; + +public class distanceK { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + // 记录父节点：node.val -> parentNode + // 题目说了树中所有节点值都是唯一的，所以可以用 node.val 代表 TreeNode + HashMap parent = new HashMap<>(); + + public List distanceK(TreeNode root, TreeNode target, int k) { + // 遍历所有节点，记录每个节点的父节点 + traverse(root, null); + + // 开始从 target 节点施放 BFS 算法，找到距离为 k 的节点 + Queue q = new LinkedList<>(); + HashSet visited = new HashSet<>(); + q.offer(target); + visited.add(target.val); + // 记录离 target 的距离 + int dist = 0; + List res = new LinkedList<>(); + + while(!q.isEmpty()) { + int size = q.size(); + for (int i = 0; i < size; i++) { + TreeNode cur = q.poll(); + if(dist == k) { + res.add(cur.val); + } + TreeNode par = parent.get(cur.val); + if(par != null && !visited.contains(par.val)) { + q.offer(par); + visited.add(par.val); + } + if(cur.left != null && !visited.contains(par.val)) { + q.offer(cur.left); + visited.add(cur.left.val); + } + if(cur.right != null && !visited.contains(par.val)) { + q.offer(cur.right); + visited.add(cur.right.val); + } + } + dist++; + } + + return res; + } + + private void traverse(TreeNode root, TreeNode parentNode) { + if (root == null) { + return; + } + parent.put(root.val, parentNode); + // 二叉树递归框架 + traverse(root.left, root); + traverse(root.right, root); + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/distributeCoins.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/distributeCoins.java new file mode 100644 index 0000000..78028eb --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/distributeCoins.java @@ -0,0 +1,42 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class distributeCoins { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public int distributeCoins(TreeNode root) { + getRest(root); + return res; + } + + int res = 0; + + // 定义：输入一棵二叉树，返回这棵二叉树中多出的硬币个数，返回负数代表缺少硬币 + int getRest(TreeNode root) { + if (root == null) { + return 0; + } + int left = getRest(root.left); + int right = getRest(root.right); + // 让当前这棵树平衡所需的移动次数 + res += Math.abs(left) + Math.abs(right) + (root.val - 1); + // 实现函数的定义 + return left + right + (root.val - 1); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/findDuplicate.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/findDuplicate.java new file mode 100644 index 0000000..7b17a3b --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/findDuplicate.java @@ -0,0 +1,21 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class findDuplicate { + public int findDuplicate(int[] nums) { + int slow = 0; + int fast = 0; + slow = nums[slow]; + fast = nums[nums[fast]]; + while(slow != fast){ + slow = nums[slow]; + fast = nums[nums[fast]]; + } + int pre1 = 0; + int pre2 = slow; + while(pre1 != pre2){ + pre1 = nums[pre1]; + pre2 = nums[pre2]; + } + return pre1; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/findPeakElement.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/findPeakElement.java new file mode 100644 index 0000000..3a50231 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/findPeakElement.java @@ -0,0 +1,18 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class findPeakElement { + + public int findPeakElement(int[] nums) { + int left = 0, right = nums.length - 1; + while (left < right) { + int mid = left + (right - left) / 2; + if (nums[mid] > nums[mid + 1]) { + right = mid; + } else { + left = mid + 1; + } + } + return left; + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/firstUniqChar.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/firstUniqChar.java new file mode 100644 index 0000000..cd84063 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/firstUniqChar.java @@ -0,0 +1,15 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.HashMap; + +public class firstUniqChar { + public char firstUniqChar(String s) { + HashMap dic = new HashMap<>(); + char[] sc = s.toCharArray(); + for(char c : sc) + dic.put(c, !dic.containsKey(c)); + for(char c : sc) + if(dic.get(c)) return c; + return ' '; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/flipEquiv.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/flipEquiv.java new file mode 100644 index 0000000..f3e959c --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/flipEquiv.java @@ -0,0 +1,37 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class flipEquiv { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + // 定义：输入两棵二叉树，判断这两棵二叉树是否是翻转等价的 + public boolean flipEquiv(TreeNode root1, TreeNode root2) { + if (root1 == null && root2 == null) { + return true; + } + if (root1 == null || root2 == null) { + return false; + } + if (root1.val != root2.val) { + return true; + } + return flipEquiv(root1.left, root2.right) && flipEquiv(root1.right, root2.left); + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/generateMatrix.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/generateMatrix.java new file mode 100644 index 0000000..6e25239 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/generateMatrix.java @@ -0,0 +1,43 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class generateMatrix { + + public static void main(String[] args) { + int[][] aa = generateMatrix(3); + System.out.println(aa); + } + + static int[][] generateMatrix(int n) { + int[][] matrix = new int[n][n]; + int upPOS = 0, lowPOS = n - 1; + int leftPOS = 0, rightPOS = n - 1; + int res = 1; + while (res <= n * n) { + if (upPOS <= lowPOS) { + for (int i = leftPOS; i <= rightPOS; i++) { + matrix[upPOS][i] = res++; + } + upPOS++; + } + if (rightPOS >= leftPOS) { + for (int i = upPOS; i <= lowPOS; i++) { + matrix[i][rightPOS] = res++; + } + rightPOS--; + } + if (lowPOS >= upPOS) { + for (int i = rightPOS; i >= leftPOS; i--) { + matrix[lowPOS][i] = res++; + } + lowPOS--; + } + if (leftPOS <= rightPOS) { + for (int i = lowPOS; i >= upPOS; i--) { + matrix[i][leftPOS] = res++; + } + leftPOS++; + } + } + return matrix; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/generateParenthesis.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/generateParenthesis.java new file mode 100644 index 0000000..7ec5476 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/generateParenthesis.java @@ -0,0 +1,26 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.ArrayList; +import java.util.List; + +public class generateParenthesis { + public List generateParenthesis(int n) { + List res = new ArrayList<>(); + if (n <= 0) return res; + dfs(n, "", res, 0, 0); + return res; + } + + private void dfs(int n, String path, List res, int open, int close) { + if (path.length() == 2 * n) { + res.add(path); + return; + } + if (open < n) { + dfs(n, path + "(", res, open + 1, close); + } + if (close < open) { + dfs(n, path + ")", res, open, close + 1); + } + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/getIntersectionNode.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/getIntersectionNode.java new file mode 100644 index 0000000..6e0be00 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/getIntersectionNode.java @@ -0,0 +1,30 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class getIntersectionNode { + class ListNode { + int val; + ListNode next; + + ListNode() { + } + + ListNode(int val) { + this.val = val; + } + + ListNode(int val, ListNode next) { + this.val = val; + this.next = next; + } + } + + public ListNode getIntersectionNode(ListNode headA, ListNode headB) { + ListNode pA = headA, pB = headB; + while(pA != pB){ + pA = pA == null? headB : pA.next; + pB = pB == null? headA : pB.next; + } + return pA; + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/getKthFromEnd.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/getKthFromEnd.java new file mode 100644 index 0000000..db0135a --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/getKthFromEnd.java @@ -0,0 +1,28 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class getKthFromEnd { + public class ListNode { + int val; + ListNode next; + + ListNode(int x) { + val = x; + } + } + + public ListNode getKthFromEnd(ListNode head, int k) { + ListNode fast = head; + ListNode slow = head; + + while (fast != null && k > 0) { + fast = fast.next; + k--; + } + while (fast != null) { + fast = fast.next; + slow = slow.next; + } + + return slow; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/hasPathSum.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/hasPathSum.java new file mode 100644 index 0000000..1c8e38c --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/hasPathSum.java @@ -0,0 +1,32 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class hasPathSum { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public boolean hasPathSum(TreeNode root, int sum) { + if (root == null) { + return false; + } + if (root.left == null && root.right == null) { + return sum == root.val; + } + return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/invertTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/invertTree.java new file mode 100644 index 0000000..9565092 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/invertTree.java @@ -0,0 +1,28 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class invertTree { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + TreeNode() {} + TreeNode(int val) { this.val = val; } + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public TreeNode invertTree(TreeNode root) { + if(root==null) { + return root; + } + invertTree(root.left); + TreeNode tmp = root.left; + root.left = root.right; + root.right = tmp; + invertTree(root.right); + return root; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isCompleteTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isCompleteTree.java new file mode 100644 index 0000000..f7af15f --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isCompleteTree.java @@ -0,0 +1,49 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; +import java.util.Queue; + +public class isCompleteTree { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public boolean isCompleteTree(TreeNode root) { + Queue dq = new LinkedList<>(); + dq.add(root); + boolean flag = false; + + while(!dq.isEmpty()) { + int size = dq.size(); + for (int i = 0; i < size; i++) { + TreeNode node = dq.poll(); + if(node == null) { + flag = true; + } else { + if(flag) { + return false; + } + dq.offer(node.left); + dq.offer(node.right); + } + } + } + return true; + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isSubPath.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isSubPath.java new file mode 100644 index 0000000..8e620e7 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isSubPath.java @@ -0,0 +1,68 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class isSubPath { + public class ListNode { + int val; + ListNode next; + + ListNode() { + } + + ListNode(int val) { + this.val = val; + } + + ListNode(int val, ListNode next) { + this.val = val; + this.next = next; + } + } + + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public boolean isSubPath(ListNode head, TreeNode root) { + if(head == null) { + return true; + } + if(root == null) { + return false; + } + if(head.val == root.val) { + if(check(head, root)){ + return true; + } + } + return isSubPath(head, root.left) || isSubPath(head, root.right); + } + + // 检查是否能够将链表嵌入二叉树 + boolean check(ListNode head, TreeNode root) { + if(head == null) { + return true; + } + if(root == null) { + return false; + } + if(head.val == root.val) { + return check(head.next, root.left) || check(head.next, root.right); + } + return false; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isSymmetric.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isSymmetric.java new file mode 100644 index 0000000..55698e3 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isSymmetric.java @@ -0,0 +1,39 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class isSymmetric { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public boolean isSymmetric(TreeNode root) { + if(root == null) { + return true; + } + return duichenTree(root.left, root.right); + } + + boolean duichenTree(TreeNode left, TreeNode right) { + if(left == null && right == null) { + return true; + } + if(left == null || right == null || left.val != right.val) { + return false; + } + return duichenTree(left.left, right.right) && duichenTree(left.right, right.left); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isValidSerialization.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isValidSerialization.java new file mode 100644 index 0000000..449f575 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/isValidSerialization.java @@ -0,0 +1,24 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; + +public class isValidSerialization { + public boolean isValidSerialization(String preorder) { + int edge = 1; + for(String node : preorder.split(",")) { + if(node.equals("#")) { + edge -= 1; + if(edge < 0) { + return false; + } + } else { + edge -= 1; + if(edge < 0) { + return false; + } + edge += 2; + } + } + return edge == 0; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/lengthOfLIS.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/lengthOfLIS.java new file mode 100644 index 0000000..5bd9005 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/lengthOfLIS.java @@ -0,0 +1,26 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.Arrays; + +public class lengthOfLIS { + + public int lengthOfLIS(int[] nums) { + if (nums.length == 0) { + return 0; + } + int[] dp = new int[nums.length]; + Arrays.fill(dp, 1); + dp[0] = 1; + int maxans = 1; + for (int i = 1; i < nums.length; i++) { + for (int j = 0; j < i; j++) { + if(nums[j] < nums[i] && dp[j] + 1 > dp[i]) { + dp[i] = dp[j] + 1; + } + } + maxans = Math.max(maxans, dp[i]); + } + return maxans; + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/lengthOfLongestSubstring.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/lengthOfLongestSubstring.java new file mode 100644 index 0000000..43e748c --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/lengthOfLongestSubstring.java @@ -0,0 +1,21 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.HashMap; + +public class lengthOfLongestSubstring { + public int lengthOfLongestSubstring(String s) { + if (s.length()==0) return 0; + HashMap map = new HashMap<>(); + int max = 0; + int left = 0; + for(int i = 0; i < s.length(); i ++){ + if(map.containsKey(s.charAt(i))){ + left = Math.max(left, map.get(s.charAt(i)) + 1); + } + map.put(s.charAt(i),i); + max = Math.max(max,i-left+1); + } + return max; + + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/levelOrderBottom.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/levelOrderBottom.java new file mode 100644 index 0000000..ef3ce5a --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/levelOrderBottom.java @@ -0,0 +1,55 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +public class levelOrderBottom { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public List> levelOrderBottom(TreeNode root) { + LinkedList> res = new LinkedList<>(); + if (root == null) { + return res; + } + + Queue q = new LinkedList<>(); + q.offer(root); + // while 循环控制从上向下一层层遍历 + while (!q.isEmpty()) { + int sz = q.size(); + // 记录这一层的节点值 + List level = new LinkedList<>(); + // for 循环控制每一层从左向右遍历 + for (int i = 0; i < sz; i++) { + TreeNode cur = q.poll(); + level.add(cur.val); + if (cur.left != null) + q.offer(cur.left); + if (cur.right != null) + q.offer(cur.right); + } + // 把每一层添加到头部，就是自底向上的层序遍历。 + res.addFirst(level); + } + return res; + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/longestCommonSubsequence.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/longestCommonSubsequence.java new file mode 100644 index 0000000..71b9d0c --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/longestCommonSubsequence.java @@ -0,0 +1,19 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class longestCommonSubsequence { + public int longestCommonSubsequence(String s1, String s2) { + int m = s1.length(), n = s2.length(); + int[][] dp = new int[m+1][n+1]; + + for (int i = 1; i <= m; i++) { + for (int j = 1; j <= n; j++) { + if(s1.charAt(i) == s2.charAt(j)) { + dp[i][j] = dp[i-1][j-1] + 1; + } else { + dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]); + } + } + } + return dp[m][n]; + } +} \ No newline at end of file diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/longestPalindrome.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/longestPalindrome.java new file mode 100644 index 0000000..cb926d1 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/longestPalindrome.java @@ -0,0 +1,25 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class longestPalindrome { + + String palinerome(String s, int l, int r) { + while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) { + l--; + r++; + } + return s.substring(l + 1, r); + } + + public String longestPalindrome(String s) { + String res = ""; + int len = s.length(); + for (int i = 0; i < len; i++) { + String s1 = palinerome(s, i, i); + String s2 = palinerome(s, i, i + 1); + res = res.length() > s1.length() ? res : s1; + res = res.length() > s2.length() ? res : s2; + } + return res; + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/lowestCommonAncestor.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/lowestCommonAncestor.java new file mode 100644 index 0000000..d9eac36 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/lowestCommonAncestor.java @@ -0,0 +1,32 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class lowestCommonAncestor { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode(int x) { + val = x; + } + } + + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if (root == null || root == p || root == q) { + return root; + } + TreeNode left = lowestCommonAncestor(root.left, p, q); + TreeNode right = lowestCommonAncestor(root.right, p, q); + if (left == null && right == null) { + return null; + } + if (left != null && right != null) { + return root; + } + if (left == null) { + return right; + } else { + return left; + } + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxDepth.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxDepth.java new file mode 100644 index 0000000..6222d05 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxDepth.java @@ -0,0 +1,31 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class maxDepth { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode(int x) { + val = x; + } + } + + int deep = 0, maxDepth = 0; + + public int maxDepth(TreeNode root) { + traverTree(root); + return maxDepth; + } + + void traverTree(TreeNode node) { + if (node == null) { + maxDepth = Math.max(maxDepth, deep); + return; + } + deep++; + traverTree(node.left); + traverTree(node.right); + deep--; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProduct.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProduct.java new file mode 100644 index 0000000..face63a --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProduct.java @@ -0,0 +1,25 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class maxProduct { + public int maxProduct(int[] nums) { + if(nums==null||nums.length==0) { + return 0; + } + int len = nums.length; + int res = nums[0]; + + int[][] dp = new int[len][2]; + dp[0][0] = nums[0]; + dp[0][1] = nums[0]; + + for (int i = 1; i < len; i++) { + dp[i][0] = Math.min(Math.min(dp[i-1][0]*nums[i],dp[i-1][1]*nums[i]),nums[i]); + dp[i][1] = Math.max(Math.max(dp[i-1][0]*nums[i],dp[i-1][1]*nums[i]),nums[i]); + + if(dp[i][1]>res) { + res = dp[i][1]; + } + } + return res; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProductTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProductTree.java new file mode 100644 index 0000000..a4e52d2 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProductTree.java @@ -0,0 +1,44 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class maxProductTree { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + long res = 0; + int treeSum = 0; + + public int maxProduct(TreeNode root) { + // 先利用求和函数得到整棵树的节点之和 + treeSum = getSum(root); + // 再次调用，利用后序位置计算子树之积 + getSum(root); + return (int) (res % (1e9 + 7)); + } + + int getSum(TreeNode root) { + if (root == null) { + return 0; + } + int left = getSum(root.left); + int right = getSum(root.right); + int rootSum = left + right + root.val; + res = Math.max(res, rootSum * (treeSum - rootSum)); + return rootSum; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProfit.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProfit.java new file mode 100644 index 0000000..3fd57d8 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProfit.java @@ -0,0 +1,12 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class maxProfit { + public int maxProfit(int[] prices) { + int res=0, min = Integer.MAX_VALUE; + for (int i = 0; i < prices.length; i++) { + min = Math.min(min, prices[i]); + res = Math.max(res, prices[i]-min); + } + return res; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProfit2.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProfit2.java new file mode 100644 index 0000000..4dc56a2 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxProfit2.java @@ -0,0 +1,16 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class maxProfit2 { + public int maxProfit(int[] prices) { + if(prices.length<=1) { + return 0; + } + int res = 0; + for (int i = 1; i < prices.length; ++i) { + if(prices[i]>prices[i-1]) { + res += prices[i] - prices[i-1]; + } + } + return res; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxSlidingWindow.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxSlidingWindow.java new file mode 100644 index 0000000..ba8db72 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxSlidingWindow.java @@ -0,0 +1,40 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.Deque; +import java.util.LinkedList; + +public class maxSlidingWindow { + public int[] maxSlidingWindow(int[] nums, int k) { + if (nums.length == 0 || k == 0) return new int[0]; + Deque deque = new LinkedList<>(); + int[] res = new int[nums.length - k + 1]; + /*for(int j = 0, i = 1 - k; j < nums.length; i++, j++) { + // 删除 deque 中对应的 nums[i-1] + if(i > 0 && deque.peekFirst() == nums[i - 1]) + deque.removeFirst(); + // 保持 deque 递减 + while(!deque.isEmpty() && deque.peekLast() < nums[j]) + deque.removeLast(); + deque.addLast(nums[j]); + // 记录窗口最大值 + if(i >= 0) + res[i] = deque.peekFirst(); + }*/ + + for (int i = 0, j = 1 - k; i < nums.length; i++, j++) { + if (j > 0 && deque.getFirst() == nums[j - 1]) { + deque.removeFirst(); + } + + while (!deque.isEmpty() && deque.peekLast() < nums[i]) { + deque.removeLast(); + } + deque.addLast(nums[i]); + + if (j > 0) { + res[j] = deque.peekFirst(); + } + } + return res; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxSubArray.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxSubArray.java new file mode 100644 index 0000000..594936d --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/maxSubArray.java @@ -0,0 +1,17 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class maxSubArray { + public int maxSubArray(int[] nums) { + if(nums==null||nums.length==0) { + return -1; + } + + int sumSub = 0; + int max = nums[0]; + for (int i = 0; i < nums.length; i++) { + sumSub = Math.max(sumSub+nums[i], nums[i]); + max = Math.max(max, sumSub); + } + return max; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/merge.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/merge.java new file mode 100644 index 0000000..d08459f --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/merge.java @@ -0,0 +1,21 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class merge { + public void merge(int[] nums1, int m, int[] nums2, int n) { + int p1 = m - 1, p2 = n - 1; + int tail = m + n - 1; + int cur; + while (p1 >= 0 || p2 >= 0) { + if (p1 == -1) { + cur = nums2[p2--]; + } else if (p2 == -1) { + cur = nums1[p1--]; + } else if (nums1[p1] > nums2[p2]) { + cur = nums1[p1--]; + } else { + cur = nums2[p2--]; + } + nums1[tail--] = cur; + } + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/minDepth.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/minDepth.java new file mode 100644 index 0000000..6a093a7 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/minDepth.java @@ -0,0 +1,52 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; +import java.util.Queue; + +public class minDepth { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public int minDepth(TreeNode root) { + if(root == null) { + return 0; + } + Queue dq = new LinkedList<>(); + dq.offer(root); + int minDeep = 1; + + while(!dq.isEmpty()) { + int size = dq.size(); + for (int i = 0; i < size; i++) { + TreeNode node = dq.poll(); + if(node.left == null && node.right == null) { + return minDeep; + } + if(node.left != null) { + dq.offer(node.left); + } + if(node.right != null) { + dq.offer(node.right); + } + } + minDeep++; + } + return minDeep; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/minDistance.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/minDistance.java new file mode 100644 index 0000000..8ab0b05 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/minDistance.java @@ -0,0 +1,21 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class minDistance { + public int minDistance(String word1, String word2) { + int m = word1.length(), n = word2.length(); + int[][] dp = new int[m][n]; + for (int i = 0; i <= m; ++i) dp[i][0] = i; + for (int i = 0; i <= n; ++i) dp[0][i] = i; + + for (int i = 1; i <= m; ++i) { + for (int j = 1; j <= n; ++j) { + if (word1.charAt(i - 1) == word2.charAt(j - 1)) { + dp[i][j] = dp[i - 1][j - 1]; + } else { + dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1; + } + } + } + return dp[m][n]; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/minimumTotal.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/minimumTotal.java new file mode 100644 index 0000000..92af812 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/minimumTotal.java @@ -0,0 +1,16 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.List; + +public class minimumTotal { + public int minimumTotal(List> triangle) { + int n = triangle.size(); + int[][] dp = new int[n + 1][n + 1]; + for (int i = n - 1; i >= 0; i--) { + for (int j = 0; j <= i; j++) { + dp[i][j] = Math.min(dp[i+1][j], dp[i+1][j+1])+triangle.get(i).get(j); + } + } + return dp[0][0]; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/multiply.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/multiply.java new file mode 100644 index 0000000..e718f84 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/multiply.java @@ -0,0 +1,49 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class multiply { + public String multiply(String num1, String num2) { + if (num1.equals("0") || num2.equals("0")) { + return "0"; + } + String ans = "0"; + int m = num1.length(), n = num2.length(); + + for (int i = n - 1; i >= 0; i--) { + StringBuffer curr = new StringBuffer(); + int add = 0; + for (int j = n - 1; j > i; j--) { + curr.append(0); + } + + int y = num2.charAt(i) - '0'; + for (int j = m - 1; j >= 0; j--) { + int x = num1.charAt(j) - '0'; + int product = x * y + add; + curr.append(product % 10); + add = product / 10; + } + + if (add != 0) { + curr.append(add % 10); + } + ans = addStrings(ans, curr.reverse().toString()); + } + return ans; + } + + public String addStrings(String num1, String num2) { + int i = num1.length() - 1, j = num2.length() - 1, add = 0; + StringBuffer ans = new StringBuffer(); + while (i >= 0 || j >= 0 || add != 0) { + int x = i >= 0 ? num1.charAt(i) - '0' : 0; + int y = j >= 0 ? num2.charAt(j) - '0' : 0; + int result = x + y + add; + ans.append(result % 10); + add = result / 10; + i--; + j--; + } + ans.reverse(); + return ans.toString(); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/myAtoi.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/myAtoi.java new file mode 100644 index 0000000..68a042d --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/myAtoi.java @@ -0,0 +1,35 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class myAtoi { + public static void main(String[] args) { + myAtoi(" "); + } + + public static int myAtoi(String s) { + int sin = 1, left = 0, res = 0,len = s.length(); + if(s==null||len==0) { + return 0; + } + while(left= '0' && s.charAt(left) <='9') { + if(res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && s.charAt(left)>'7')) { + return sin==1 ? Integer.MAX_VALUE : Integer.MIN_VALUE; + } + res = res*10 + (s.charAt(left) - '0'); + left ++; + } + + return res * sin; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/myBuildTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/myBuildTree.java new file mode 100644 index 0000000..a881660 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/myBuildTree.java @@ -0,0 +1,61 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.HashMap; +import java.util.Map; + +public class myBuildTree { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + private Map indexMap; + + public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) { + if (preorder_left > preorder_right) { + return null; + } + + // 前序遍历中的第一个节点就是根节点 + int preorder_root = preorder_left; + // 在中序遍历中定位根节点 + int inorder_root = indexMap.get(preorder[preorder_root]); + + // 先把根节点建立出来 + TreeNode root = new TreeNode(preorder[preorder_root]); + // 得到左子树中的节点数目 + int size_left_subtree = inorder_root - inorder_left; + // 递归地构造左子树，并连接到根节点 + // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素 + root.left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1); + // 递归地构造右子树，并连接到根节点 + // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素 + root.right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right); + return root; + } + + public TreeNode buildTree(int[] preorder, int[] inorder) { + int n = preorder.length; + // 构造哈希映射，帮助我们快速定位根节点 + indexMap = new HashMap(); + for (int i = 0; i < n; i++) { + indexMap.put(inorder[i], i); + } + return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1); + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/myPow.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/myPow.java new file mode 100644 index 0000000..889e073 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/myPow.java @@ -0,0 +1,16 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class myPow { + public double myPow(double x, int n) { + long N = n; + return N > 0 ? quickMul(x, N) : 1 / quickMul(x, -N); + } + + public double quickMul(double x, long N) { + if (N == 0) { + return 1; + } + double y = quickMul(x, N / 2); + return N % 2 == 0 ? y * y : y * y * x; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/mySqrt.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/mySqrt.java new file mode 100644 index 0000000..dcc5039 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/mySqrt.java @@ -0,0 +1,18 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class mySqrt { + + public int mySqrt(int x) { + int l = 0, r = x, ans = -1; + while (l <= r) { + int mid = l + (r - l) / 2; + if ((long) mid * mid <= x) { + ans = mid; + l = mid + 1; + } else { + r = mid - 1; + } + } + return ans; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/numIslands.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/numIslands.java new file mode 100644 index 0000000..1a89237 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/numIslands.java @@ -0,0 +1,34 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class numIslands { + public int numIslands(char[][] grid) { + if (grid.length == 0 || grid[0].length == 0) { + return 0; + } + + int count = 0; + for (int r = 0; r < grid.length; r++) { + for (int c = 0; c < grid[0].length; c++) { + if (grid[r][c] == '1') { + dfs(grid, r, c); + count++; + } + } + } + return count; + } + + void dfs(char[][] grid, int r, int c) { + if (!(0 <= r && r < grid.length && 0 <= c && c < grid[0].length)) { + return; + } + if (grid[r][c] != '1') { + return; + } + grid[r][c] = '2'; + dfs(grid, r - 1, c); + dfs(grid, r + 1, c); + dfs(grid, r, c - 1); + dfs(grid, r, c + 1); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/pathInZigZagTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/pathInZigZagTree.java new file mode 100644 index 0000000..54607dd --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/pathInZigZagTree.java @@ -0,0 +1,33 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class pathInZigZagTree { + public List pathInZigZagTree(int label) { + ArrayList path = new ArrayList<>(); + while (label >= 1) { + path.add(label); + label = label / 2; + + int depth = log(label); + int[] range = getLevelRange(depth); + // 由于之字形分布，根据上层的节点取值范围，修正父节点 + label = range[1] - (label - range[0]); + } + // 反转成从根节点到目标节点的路径 + Collections.reverse(path); + return path; + } + + // 获取第 n 层节点的取值范围 + private int[] getLevelRange(int n) { + int p = (int) Math.pow(2, n); + return new int[]{p, 2 * p - 1}; + } + + int log(int x) { + return (int) (Math.log(x) / Math.log(2)); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/permute.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/permute.java new file mode 100644 index 0000000..29c965f --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/permute.java @@ -0,0 +1,46 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; +import java.util.List; + +public class permute { + List> res = new LinkedList<>(); + // 记录回溯算法的递归路径 + LinkedList track = new LinkedList<>(); + // track 中的元素会被标记为 true + boolean[] used; + + /* 主函数，输入一组不重复的数字，返回它们的全排列 */ + public List> permute(int[] nums) { + used = new boolean[nums.length]; + backtrack(nums); + return res; + } + + // 回溯算法核心函数 + void backtrack(int[] nums) { + // base case，到达叶子节点 + if (track.size() == nums.length) { + // 收集叶子节点上的值 + res.add(new LinkedList(track)); + return; + } + + // 回溯算法标准框架 + for (int i = 0; i < nums.length; i++) { + // 已经存在 track 中的元素，不能重复选择 + if (used[i]) { + continue; + } + // 做选择 + used[i] = true; + track.addLast(nums[i]); + // 进入下一层回溯树 + backtrack(nums); + // 取消选择 + track.removeLast(); + used[i] = false; + } + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/permuteUnique.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/permuteUnique.java new file mode 100644 index 0000000..e7391f7 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/permuteUnique.java @@ -0,0 +1,42 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.Arrays; +import java.util.LinkedList; +import java.util.List; + +public class permuteUnique { + List> res = new LinkedList<>(); + LinkedList track = new LinkedList<>(); + boolean[] used; + + public List> permuteUnique(int[] nums) { + // 先排序，让相同的元素靠在一起 + Arrays.sort(nums); + used = new boolean[nums.length]; + backtrack(nums); + return res; + } + + void backtrack(int[] nums) { + if (track.size() == nums.length) { + res.add(new LinkedList(track)); + return; + } + + for (int i = 0; i < nums.length; i++) { + if (used[i]) { + continue; + } + // 新添加的剪枝逻辑，固定相同的元素在排列中的相对位置 + if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) { + continue; + } + track.add(nums[i]); + used[i] = true; + backtrack(nums); + track.removeLast(); + used[i] = false; + } + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/pruneTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/pruneTree.java new file mode 100644 index 0000000..300934e --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/pruneTree.java @@ -0,0 +1,35 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class pruneTree { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + // 定义：输入一棵二叉树，返回的二叉树叶子节点都是 1 + public TreeNode pruneTree(TreeNode root) { + if(root == null) { + return null; + } + root.left = pruneTree(root.left); + root.right = pruneTree(root.right); + if(root.val == 0 && root.left == null && root.right ==null) { + return null; + } + return root; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/reorderList.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/reorderList.java new file mode 100644 index 0000000..e33d360 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/reorderList.java @@ -0,0 +1,46 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.ArrayList; +import java.util.List; + +public class reorderList { + public class ListNode { + int val; + ListNode next; + + ListNode() { + } + + ListNode(int val) { + this.val = val; + } + + ListNode(int val, ListNode next) { + this.val = val; + this.next = next; + } + } + + public void reorderList(ListNode head) { + if (head == null) { + return; + } + List list = new ArrayList<>(); + ListNode node = head; + while (node != null) { + list.add(node); + node = node.next; + } + int i = 0, j = list.size() - 1; + while (i < j) { + list.get(i).next = list.get(j); + i++; + if (i == j) { + break; + } + list.get(j).next = list.get(i); + j--; + } + list.get(i).next = null; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/restoreIpAddresses.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/restoreIpAddresses.java new file mode 100644 index 0000000..35fecb8 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/restoreIpAddresses.java @@ -0,0 +1,94 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +public class restoreIpAddresses { + List res = new ArrayList<>(); + List path = new ArrayList<>(); + + public List restoreIpAddresses(String s) { + //这里就是对字符串的预处理，但是对于测试用例来说我觉得用处不大，毕竟不会蠢到用13位数字让你分割 + if (s.length() < 4 || s.length() > 12) { + return res; + } + //这里就是套用最经典的回溯模板了，相比于分割字符串只加入分割线一个参数以外，这里还需要添加额外的层数参数level + //因为合法的IP地址只有四段，我们不能无限对其进行分割 + backtracking(s, 0, 0); + return res; + } + + void backtracking(String s, int start, int level) { + if (level == 4) { + res.add(String.join(".", path)); + return; + } + for (int i = start; i < s.length(); i++) { + if (s.length() - (start + 1) > 3 * (3 - level)) { + continue; + } + if (!validStrIP(s.substring(start, i + 1))) { + continue; + } + path.add(s.substring(start, i + 1)); + backtracking(s, start + 1, level + 1); + path.remove(path.size() - 1); + } + } + + boolean validStrIP(String s) { + if (s.charAt(0) == '0' && s.length() > 1) { + return false; + } + if (s.length() > 3) { + return false; + } + if (Integer.valueOf(s) > 255) { + return false; + } + return true; + } + + /*void backtracking(String s, int splitIndex, int level) { + //递归终止条件，分割的四个字符串都是合法的IP地址 + if (level == 4) { + //在代码的最后再利用join函数加上“.”,构造IP地址的表示形式 + res.add(String.join(".", path)); + return; + } + for (int i = splitIndex; i < s.length(); i++) { + //每一次分割之后，对剩余字符长度是否合理进行判断，剪枝操作，优化运行速度 + if ((s.length() - (i + 1)) > 3 * (3 - level)) { + continue; + } + //如果分割的字符串不是合理的IP地址，跳过 + if (!isValidIp(s.substring(splitIndex, i + 1))) { + continue; + } + //把合法的IP地址段加入path存储 + path.add(s.substring(splitIndex, i + 1)); + //每次把分割线往后移一位，且段数level+1 + backtracking(s, i + 1, level + 1); + //进行回溯操作 + path.remove(path.size() - 1); + } + } + + // 判断分割出来的每一段字符串是否是合法的IP地址 + boolean isValidIp(String s) { + //判断其是否含有前导0 + if (s.charAt(0) == '0' && s.length() > 1) { + return false; + } + //长度为4就直接舍弃，加上这一步是为了后面parseInt做准备,防止超过了Integer可以表示的整数范围 + if (s.length() > 3) { + return false; + } + //将字符转为int判断是否大于255，因为题目明确说了只由数字组成，所以这里没有对非数字的字符进行判断 + if (Integer.parseInt(s) > 255) { + return false; + } + return true; + }*/ +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/reverseBetween.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/reverseBetween.java new file mode 100644 index 0000000..af72eb1 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/reverseBetween.java @@ -0,0 +1,61 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class reverseBetween { + class ListNode { + int val; + ListNode next; + + ListNode() { + } + + ListNode(int val) { + this.val = val; + } + + ListNode(int val, ListNode next) { + this.val = val; + this.next = next; + } + } + + ListNode reverse(ListNode head) { + if (head == null || head.next == null) { + return head; + } + ListNode last = reverse(head.next); + head.next.next = head; + head.next = null; + return last; + } + + + ListNode successor = null; // 后驱节点 + // 反转以 head 为起点的 n 个节点，返回新的头结点 + ListNode reverseN(ListNode head, int n) { + if (n == 1) { + // 记录第 n + 1 个节点 + successor = head.next; + return head; + } + // 以 head.next 为起点，需要反转前 n - 1 个节点 + ListNode last = reverseN(head.next, n - 1); + + head.next.next = head; + // 让反转之后的 head 节点和后面的节点连起来 + head.next = successor; + return last; + } + + + ListNode reverseBetween(ListNode head, int m, int n) { + // base case + if (m == 1) { + return reverseN(head, n); + } + // 前进到反转的起点触发 base case + head.next = reverseBetween(head.next, m - 1, n - 1); + return head; + } + + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/rightSideView.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/rightSideView.java new file mode 100644 index 0000000..cfce6dc --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/rightSideView.java @@ -0,0 +1,56 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +public class rightSideView { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + /* BFS 层序遍历解法 */ + public List rightSideView(TreeNode root) { + List res = new LinkedList<>(); + if (root == null) { + return res; + } + // BFS 层序遍历，计算右侧视图 + Queue q = new LinkedList<>(); + q.offer(root); + // while 循环控制从上向下一层层遍历 + while (!q.isEmpty()) { + int sz = q.size(); + // 每一层头部就是最右侧的元素 + TreeNode last = q.peek(); + for (int i = 0; i < sz; i++) { + TreeNode cur = q.poll(); + // 控制每一层从右向左遍历 + if (cur.right != null) { + q.offer(cur.right); + } + if (cur.left != null) { + q.offer(cur.left); + } + } + // 每一层的最后一个节点就是二叉树的右侧视图 + res.add(last.val); + } + return res; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/rotate.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/rotate.java new file mode 100644 index 0000000..efaa91d --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/rotate.java @@ -0,0 +1,30 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class rotate { + public void rotate(int[][] matrix) { + int n = matrix.length; + for (int i = 0; i < n; i++) { + for (int j = i; j < n; j++) { + int tmp = matrix[i][j]; + matrix[i][j] = matrix[j][i]; + matrix[j][i] = tmp; + } + } + for (int[] row : matrix) { + reverse(row); + } + } + + // 反转一维数组 + void reverse(int[] arr) { + int i = 0, j = arr.length - 1; + while (j > i) { + // swap(arr[i], arr[j]); + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + i++; + j--; + } + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/rotateMatrix.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/rotateMatrix.java new file mode 100644 index 0000000..a3f3d3a --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/rotateMatrix.java @@ -0,0 +1,33 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class rotateMatrix { + + // 将二维矩阵原地顺时针旋转 90 度 + public void rotate(int[][] matrix) { + int n = matrix.length; + for (int i = 0; i < n; i++) { + for (int j = i; j < n; j++) { + int tmp = matrix[i][j]; + matrix[i][j] = matrix[j][i]; + matrix[j][i] = tmp; + } + } + for (int[] row : matrix) { + reverse(row); + } + } + + // 反转一维数组 + void reverse(int[] arr) { + int i = 0, j = arr.length - 1; + while (j > i) { + // swap(arr[i], arr[j]); + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + i++; + j--; + } + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/sortColors.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/sortColors.java new file mode 100644 index 0000000..917e1a5 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/sortColors.java @@ -0,0 +1,25 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class sortColors { + + public void sortColors(int[] nums) { + int left = 0, right = nums.length - 1; + for (int i = 0; i <= right; i++) { + if (nums[i] == 0) { + swap(nums, left, i); + left++; + } + if (nums[i] == 2) { + swap(nums, right, i); + right--; + i--; + } + } + } + + void swap(int[] nums, int l, int r) { + int tep = nums[l]; + nums[l] = nums[r]; + nums[r] = tep; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/sortList.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/sortList.java new file mode 100644 index 0000000..dad8d4f --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/sortList.java @@ -0,0 +1,111 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; + +public class sortList { + public class ListNode { + int val; + ListNode next; + + ListNode() { + } + + ListNode(int val) { + this.val = val; + } + + ListNode(int val, ListNode next) { + this.val = val; + this.next = next; + } + } + + public ListNode sortList(ListNode head) { + return sortList(head, null); + } + + public ListNode sortList(ListNode head, ListNode tail) { + if(head == null) { + return head; + } + if(head.next == tail) { + return head; + } + ListNode slow = head, fast = head; + while (fast != null && fast != null) { + slow = slow.next; + fast = fast.next.next; + } + ListNode mid = slow; + ListNode l1 = sortList(head, mid); + ListNode l2 = sortList(mid, tail); + ListNode sorted = merge(l1, l2); + return sorted; + } + + ListNode merge(ListNode l1, ListNode l2) { + ListNode dummy = new ListNode(0); + ListNode cur = dummy; + while (l1 != null && l2 != null) { + if (l1.val <= l2.val) { + cur.next = l1; + l1 = l1.next; + } else { + cur.next = l2; + l2 = l2.next; + } + cur = cur.next; + } + if (l1 != null) { + cur.next = l1; + } + if (l2 != null) { + cur.next = l2; + } + return dummy.next; + } + + /*public ListNode sortList(ListNode head, ListNode tail) { + if (head == null) { + return head; + } + if (head.next == tail) { + head.next = null; + return head; + } + ListNode slow = head, fast = head; + while (fast != tail) { + slow = slow.next; + fast = fast.next; + if (fast != tail) { + fast = fast.next; + } + } + ListNode mid = slow; + ListNode list1 = sortList(head, mid); + ListNode list2 = sortList(mid, tail); + ListNode sorted = merge(list1, list2); + return sorted; + } + + public ListNode merge(ListNode head1, ListNode head2) { + ListNode dummyHead = new ListNode(0); + ListNode temp = dummyHead, temp1 = head1, temp2 = head2; + while (temp1 != null && temp2 != null) { + if (temp1.val <= temp2.val) { + temp.next = temp1; + temp1 = temp1.next; + } else { + temp.next = temp2; + temp2 = temp2.next; + } + temp = temp.next; + } + if (temp1 != null) { + temp.next = temp1; + } else if (temp2 != null) { + temp.next = temp2; + } + return dummyHead.next; + }*/ +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/subsets.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/subsets.java new file mode 100644 index 0000000..7aa420b --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/subsets.java @@ -0,0 +1,23 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.ArrayList; +import java.util.List; + +public class subsets { + + List> res = new ArrayList<>(); + public List> subsets(int[] nums) { + backtrack(0, nums, new ArrayList()); + return res; + + } + + private void backtrack(int i, int[] nums, ArrayList tmp) { + res.add(new ArrayList<>(tmp)); + for (int j = i; j < nums.length; j++) { + tmp.add(nums[j]); + backtrack(j + 1, nums, tmp); + tmp.remove(tmp.size() - 1); + } + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/subsetsWithDup.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/subsetsWithDup.java new file mode 100644 index 0000000..0ca2a15 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/subsetsWithDup.java @@ -0,0 +1,33 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.Arrays; +import java.util.LinkedList; +import java.util.List; + +public class subsetsWithDup { + List> res = new LinkedList<>(); + LinkedList track = new LinkedList<>(); + + public List> subsetsWithDup(int[] nums) { + // 先排序，让相同的元素靠在一起 + Arrays.sort(nums); + backtrack(nums, 0); + return res; + } + + void backtrack(int[] nums, int start) { + // 前序位置，每个节点的值都是一个子集 + res.add(new LinkedList<>(track)); + + for (int i = start; i < nums.length; i++) { + // 剪枝逻辑，值相同的相邻树枝，只遍历第一条 + if (i > start && nums[i] == nums[i - 1]) { + continue; + } + track.addLast(nums[i]); + backtrack(nums, i + 1); + track.removeLast(); + } + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/threeSum.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/threeSum.java new file mode 100644 index 0000000..69b4e74 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/threeSum.java @@ -0,0 +1,67 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; + +public class threeSum { + public List> threeSum(int[] nums) { + if (nums.length < 3) { + return new ArrayList<>(); + } + //排序 + Arrays.sort(nums); + HashMap map = new HashMap<>(); + List> resultarr = new ArrayList<>(); + //存入哈希表 + for (int i = 0; i < nums.length; i++) { + map.put(nums[i], i); + } + + Integer t; + int target = 0; + for(int i=0; i0 && nums[i]==nums[i-1]) { + continue; + } + for(int j=i+1; ji+1 && nums[j]==nums[j-1]) { + continue; + } + if((t=map.get(target-nums[j]))!=null) { + if(t>j){ + resultarr.add(new ArrayList<>(Arrays.asList(nums[i],nums[j],nums[t]))); + } else { + break; + } + } + } + } + /*for (int i = 0; i < nums.length; ++i) { + target = -nums[i]; + //去重 + if (i > 0 && nums[i] == nums[i - 1]) { + continue; + } + for (int j = i + 1; j < nums.length; ++j) { + if (j > i + 1 && nums[j] == nums[j - 1]) { + continue; + } + if ((t = map.get(target - nums[j])) != null) { + //符合要求的情况,存入 + if (t > j) { + resultarr.add(new ArrayList<> + (Arrays.asList(nums[i], nums[j], nums[t]))); + + } else { + break; + } + } + } + }*/ + + return resultarr; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/topKFrequent.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/topKFrequent.java new file mode 100644 index 0000000..e7352be --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/topKFrequent.java @@ -0,0 +1,29 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import javafx.util.Pair; + +import java.util.*; + +public class topKFrequent { + public List topKFrequent(String[] words, int k) { + Map map = new HashMap<>(); + for (String word : words) { + map.put(word, map.getOrDefault(word, 0) + 1); + } + //先按出现频率升序排序, 再按照字母字典序排序 + PriorityQueue> queue = new PriorityQueue<>( + (o1, o2) -> o2.getValue().equals(o1.getValue()) ? o2.getKey().compareTo(o1.getKey()) : o1.getValue() - o2.getValue()); + + for (Map.Entry entry : map.entrySet()) { + queue.offer(new Pair<>(entry.getKey(), entry.getValue())); + if (queue.size() > k){ + queue.poll(); + } + } + LinkedList ans = new LinkedList<>(); + while (!queue.isEmpty()){ + ans.addFirst(queue.poll().getKey()); + } + return ans; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/traverTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/traverTree.java new file mode 100644 index 0000000..cd81d7e --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/traverTree.java @@ -0,0 +1,44 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class traverTree { + + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + int max = Integer.MIN_VALUE; + + public int maxPathSum(TreeNode root) { + traverTree(root); + return max; + } + + int traverTree(TreeNode node) { + if (node == null) { + return 0; + } + + int left = traverTree(node.left); + int right = traverTree(node.right); + int sum = node.val + left+right; + max = Math.max(max,sum); + + return Math.max(0,node.val+Math.max(left,right)); + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/treeToDoublyList.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/treeToDoublyList.java new file mode 100644 index 0000000..4297de2 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/treeToDoublyList.java @@ -0,0 +1,48 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class treeToDoublyList { + class Node { + public int val; + public Node left; + public Node right; + + public Node() { + } + + public Node(int _val) { + val = _val; + } + + public Node(int _val, Node _left, Node _right) { + val = _val; + left = _left; + right = _right; + } + } + + + Node pre, head; + + public Node treeToDoublyList(Node root) { + if (root == null) return null; + traverTree(root); + head.left = pre; + pre.right = head; + return head; + } + + void traverTree(Node node) { + if (node == null) { + return; + } + traverTree(node.left); + if (head == null) { + head = node; + } else { + pre.right = node; + } + node.left = pre; + pre = node; + traverTree(node.right); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/triangleNumber.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/triangleNumber.java new file mode 100644 index 0000000..178c5d9 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/triangleNumber.java @@ -0,0 +1,27 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.Arrays; + +public class triangleNumber { + public int triangleNumber(int[] nums) { + int n = nums.length; + Arrays.sort(nums); + int ans = 0; + for (int i = 0; i < n; ++i) { + for (int j = i+1; j < n; j++) { + int left = j+1, right = n-1, k = j; + while(left < right) { + int mid = left + (right - left) / 2; + if(nums[mid] < nums[i] + nums[j]) { + k = mid; + left = mid + 1; + } else { + right = mid - 1; + } + } + ans += k - j; + } + } + return ans; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/uniquePaths.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/uniquePaths.java new file mode 100644 index 0000000..d32512c --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/uniquePaths.java @@ -0,0 +1,30 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class uniquePaths { + // 备忘录 + int[][] memo; + + public int uniquePaths(int m, int n) { + memo = new int[m][n]; + return dp(m - 1, n - 1); + } + + // 定义：从 (0, 0) 到 (x, y) 有 dp(x, y) 条路径 + int dp(int x, int y) { + // base case + if (x == 0 && y == 0) { + return 1; + } + if (x < 0 || y < 0) { + return 0; + } + // 避免冗余计算 + if (memo[x][y] > 0) { + return memo[x][y]; + } + // 状态转移方程： + // 到达 (x, y) 的路径数等于到达 (x - 1, y) 和 (x, y - 1) 路径数之和 + memo[x][y] = dp(x - 1, y) + dp(x, y - 1); + return memo[x][y]; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/validateBinaryTreeNodes.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/validateBinaryTreeNodes.java new file mode 100644 index 0000000..ea27d72 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/validateBinaryTreeNodes.java @@ -0,0 +1,80 @@ +package com.hks.eightsortingalgorithms.leetcode; + +public class validateBinaryTreeNodes { + + public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) { + // 记录每个节点的入度 + int[] indegree = new int[n]; + for (int i = 0; i < n; i++) { + if (leftChild[i] != -1) { + indegree[leftChild[i]]++; + } + if (rightChild[i] != -1) { + indegree[rightChild[i]]++; + } + } + // 按道理应该有且只有根节点的入度为 0， + // 其他节点的入度都必须为 1 + int root = -1; + for (int i = 0; i < n; i++) { + if (indegree[i] == 0) { + if (root != -1) { + // 有多个入度为 0 的节点 + return false; + } + root = i; + } else if (indegree[i] != 1) { + // 除了根节点外其他节点的入度都必须为 1 + return false; + } + } + + // 如果没有根节点，那肯定不是合法二叉树 + if (root == -1) { + return false; + } + + // 为了凸显二叉树遍历框架，我把这些都作为全局变量 + this.leftChild = leftChild; + this.rightChild = rightChild; + this.visited = new boolean[n]; + + // 用二叉树遍历框架进行遍历， + // 保证树中只有一个联通分量且不成环 + traverse(root); + // 遍历过程中发现成环了，说明肯定不是二叉树 + if (hasCycle) { + return false; + } + // 如果一次遍历没有经过所有节点，也说明不是二叉树 + for (int i = 0; i < n; i++) { + if (visited[i] != true) { + return false; + } + } + // 能通过上面的检测，判定是一棵二叉树 + return true; + } + + int[] leftChild, rightChild; + // 记录遍历过的节点，防止成环 + boolean[] visited; + boolean hasCycle = false; + + // 二叉树遍历函数 + void traverse(int root) { + if (root == -1 || hasCycle) { + return; + } + // 走了回头路，说明成环了 + if (visited[root]) { + hasCycle = true; + return; + } + visited[root] = true; + + traverse(leftChild[root]); + traverse(rightChild[root]); + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/widthOfBinaryTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/widthOfBinaryTree.java new file mode 100644 index 0000000..03a5283 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/widthOfBinaryTree.java @@ -0,0 +1,75 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.Deque; +import java.util.LinkedList; +import java.util.Queue; + +public class widthOfBinaryTree { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + // 记录节点和对应编号 + class Pair { + TreeNode node; + int id; + + public Pair(TreeNode node, int id) { + this.node = node; + this.id = id; + } + } + + public int widthOfBinaryTree(TreeNode root) { + if (root == null) { + return 0; + } + // 记录最大的宽度 + int maxWidth = 0; + // 标准 BFS 层序遍历算法 + Queue q = new LinkedList<>(); + q.offer(new Pair(root, 1)); + // 从上到下遍历整棵树 + while (!q.isEmpty()) { + int sz = q.size(); + int start = 0, end = 0; + // 从左到右遍历每一行 + for (int i = 0; i < sz; i++) { + Pair cur = q.poll(); + TreeNode curNode = cur.node; + int curId = cur.id; + // 记录当前行第一个和最后一个节点的编号 + if (i == 0) { + start = curId; + } + if (i == sz - 1) { + end = curId; + } + // 左右子节点入队，同时记录对应节点的编号 + if (curNode.left != null) { + q.offer(new Pair(curNode.left, curId * 2)); + } + if (curNode.right != null) { + q.offer(new Pair(curNode.right, curId * 2 + 1)); + } + } + // 用当前行的宽度更新最大宽度 + maxWidth = Math.max(maxWidth, end - start + 1); + } + return maxWidth; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/zigzagLevelOrder.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/zigzagLevelOrder.java new file mode 100644 index 0000000..049df58 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/leetcode/zigzagLevelOrder.java @@ -0,0 +1,64 @@ +package com.hks.eightsortingalgorithms.leetcode; + +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +public class zigzagLevelOrder { + public class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode() { + } + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + } + + public List> zigzagLevelOrder(TreeNode root) { + List> res = new LinkedList<>(); + if (root == null) { + return res; + } + + Queue q = new LinkedList<>(); + q.offer(root); + // 为 true 时向右，false 时向左 + boolean flag = true; + + // while 循环控制从上向下一层层遍历 + while (!q.isEmpty()) { + int sz = q.size(); + // 记录这一层的节点值 + LinkedList level = new LinkedList<>(); + // for 循环控制每一层从左向右遍历 + for (int i = 0; i < sz; i++) { + TreeNode cur = q.poll(); + // 实现 z 字形遍历 + if (flag) { + level.addLast(cur.val); + } else { + level.addFirst(cur.val); + } + if (cur.left != null) + q.offer(cur.left); + if (cur.right != null) + q.offer(cur.right); + } + // 切换方向 + flag = !flag; + res.add(level); + } + return res; + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/method/sort/impl/QuickAlgorithmsImpl.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/method/sort/impl/QuickAlgorithmsImpl.java index 4c23442..d2a8fe2 100644 --- a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/method/sort/impl/QuickAlgorithmsImpl.java +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/method/sort/impl/QuickAlgorithmsImpl.java @@ -3,8 +3,12 @@ import com.hks.eightsortingalgorithms.method.sort.QuickAlgorithms; import org.springframework.stereotype.Service; +import java.util.concurrent.Semaphore; +import java.util.concurrent.locks.AbstractQueuedSynchronizer; + @Service public class QuickAlgorithmsImpl implements QuickAlgorithms { + private Semaphore fooSema = new Semaphore(1); @Override public int[] sort(int[] intArr) { diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/multithread/JiouPrint.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/multithread/JiouPrint.java new file mode 100644 index 0000000..4380998 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/multithread/JiouPrint.java @@ -0,0 +1,36 @@ +package com.hks.eightsortingalgorithms.multithread; + +import java.util.concurrent.Semaphore; + +public class JiouPrint { + Semaphore semaphore = new Semaphore(0); + + public void main(String[] args) { + int i = 0; + + } + + class printJ implements Runnable { + @Override + public void run() { + for (int i = 1; i < 10; i = i + 2) { + try { + semaphore.acquire(); + System.out.println("=======" + i); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + } + + class printO implements Runnable { + @Override + public void run() { + for (int i = 0; i < 10; i = i + 2) { + System.out.println("=======" + i); + semaphore.release(); + } + } + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LInkedRollbackStr1.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LInkedRollbackStr1.java new file mode 100644 index 0000000..f4e179e --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LInkedRollbackStr1.java @@ -0,0 +1,42 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class LInkedRollbackStr1 { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static boolean rollbackStr(Node head) { + Stack stack = new Stack<>(); + Node dummy = head; + while (dummy != null) { + stack.push(dummy.value); + dummy = dummy.next; + } + while (head != null) { + int val = stack.pop(); + if (val != head.value) { + return false; + } + head = head.next; + } + return true; + } + + public static void main(String[] args) { + Node head = new Node(1); + Node cur = head; + for (int i = 0; i < 2; i++) { + cur.next = new Node(i); + cur = cur.next; + } + boolean reverseNode = rollbackStr(head); + System.out.println(reverseNode); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LInkedRollbackStr2.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LInkedRollbackStr2.java new file mode 100644 index 0000000..3057c4d --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LInkedRollbackStr2.java @@ -0,0 +1,46 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class LInkedRollbackStr2 { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static boolean rollbackStr(Node head) { + Node dummy = head; + Node next = head.next; + while (dummy != null && dummy.next.next != null) { + next = dummy.next; + dummy = dummy.next.next; + } + Stack stack = new Stack<>(); + while (next != null) { + stack.push(next.value); + next = next.next; + } + while (!stack.isEmpty()) { + if (head.value != stack.pop()) { + return false; + } + head = head.next; + } + return true; + } + + public static void main(String[] args) { + Node head = new Node(1); + Node cur = head; + for (int i = 0; i < 2; i++) { + cur.next = new Node(i); + cur = cur.next; + } + boolean reverseNode = rollbackStr(head); + System.out.println(reverseNode); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LInkedRollbackStr3_Hard.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LInkedRollbackStr3_Hard.java new file mode 100644 index 0000000..15d5d30 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LInkedRollbackStr3_Hard.java @@ -0,0 +1,46 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class LInkedRollbackStr3_Hard { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static boolean rollbackStr(Node head) { + Node dummy = head; + Node next = head.next; + while (dummy != null && dummy.next.next != null) { + next = dummy.next; + dummy = dummy.next.next; + } + Stack stack = new Stack<>(); + while (next != null) { + stack.push(next.value); + next = next.next; + } + while (!stack.isEmpty()) { + if (head.value != stack.pop()) { + return false; + } + head = head.next; + } + return true; + } + + public static void main(String[] args) { + Node head = new Node(1); + Node cur = head; + for (int i = 0; i < 2; i++) { + cur.next = new Node(i); + cur = cur.next; + } + boolean reverseNode = rollbackStr(head); + System.out.println(reverseNode); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedCommon.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedCommon.java new file mode 100644 index 0000000..50ba58b --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedCommon.java @@ -0,0 +1,41 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class LinkedCommon { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static void printCommonValue(Node node1, Node node2) { + while (node1.next != null && node2.next != null) { + if (node1.value == node2.value) { + System.out.println(node1.value); + node1 = node1.next; + node2 = node2.next; + } else if (node1.value < node2.value) { + node1 = node1.next; + } else { + node2 = node2.next; + } + } + } + + public static void main(String[] args) { + Node head = null; + Node node = null; + for (int i = 0; i < 5; i++) { + Node node1 = new Node(i); + if (head == null) { + head = node1; + } else { + node.next = node1; + } + node = node1; + } + printCommonValue(head, head); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedDelAB.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedDelAB.java new file mode 100644 index 0000000..dfa1b06 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedDelAB.java @@ -0,0 +1,44 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class LinkedDelAB { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node removeByRatio(Node head, int a, int b) { + if (a < 1 || a > b) { + return head; + } + int n = 0; + Node cur = head; + while (cur != null) { + n++; + cur = cur.next; + } + n = (int) Math.ceil((double) (a * n) / (double) b); + if (n > 1) { + cur = head; + while (--n != 1) { + cur = cur.next; + } + cur.next = cur.next.next; + } + return head; + } + + public static void main(String[] args) { + Node head = new Node(-1); + Node cur = head; + for (int i = 0; i < 5; i++) { + cur.next = new Node(i); + cur = cur.next; + } + Node delK = removeByRatio(head, 3, 5); + System.out.println(delK); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedDelLastK.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedDelLastK.java new file mode 100644 index 0000000..3bbaf09 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedDelLastK.java @@ -0,0 +1,52 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class LinkedDelLastK { + public static class Node { + public int value; + public Node pre; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node removeLastK(Node head, int k) { + if (head == null || k < 1) { + return head; + } + Node cur = head; + while (cur != null) { + k--; + cur = cur.next; + } + if (k == 0) { + head = head.next; + head.pre = null; + } + cur = head; + while (k < 0) { + k++; + if (k == 0) { + Node del = cur.next; + cur.next = del.next; + del.pre = cur; + } + cur = cur.next; + } + return head; + } + + public static void main(String[] args) { + Node head = new Node(-1); + Node cur = head; + for (int i = 0; i < 5; i++) { + Node node1 = new Node(i); + cur.next = node1; + node1.pre = cur; + cur = cur.next; + } + Node delK = removeLastK(head, 6); + System.out.println(delK); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedDelMid.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedDelMid.java new file mode 100644 index 0000000..176e62a --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedDelMid.java @@ -0,0 +1,40 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class LinkedDelMid { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node removeMidNode(Node head) { + if (head == null || head.next == null) { + return head; + } + if (head.next.next == null) { + return head.next; + } + Node pre = head; + Node cur = head.next.next; + while (cur.next != null && cur.next.next != null) { + pre = pre.next; + cur = cur.next.next; + } + pre.next = pre.next.next; + return head; + } + + public static void main(String[] args) { + Node head = new Node(-1); + Node cur = head; + for (int i = 0; i < 5; i++) { + cur.next = new Node(i); + cur = cur.next; + } + Node delK = removeMidNode(head); + System.out.println(delK); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedLoop.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedLoop.java new file mode 100644 index 0000000..0d60aab --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedLoop.java @@ -0,0 +1,48 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class LinkedLoop { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node getLoopNode(Node head) { + if (head == null || head.next == null || head.next.next == null) { + return null; + } + Node n1 = head.next; + Node n2 = head.next.next; + while (n1 != n2) { + if (n2.next == null || n2.next.next == null) { + return null; + } + n2 = n2.next.next; + n1 = n1.next; + } + n2 = head; //n2-> walk again from head + while (n1 != n2) { + n1 = n1.next; + n2 = n2.next; + } + return n1; + } + + public static void main(String[] args) { + Node head = new Node(0); + Node cur = head; + for (int i = 1; i < 3; i++) { + cur.next = new Node(i); + cur = cur.next; + if (i == 2) { + cur.next = head.next; + } + } + + Node sum = getLoopNode(head); + System.out.println(sum); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedPartitionSort_Hard.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedPartitionSort_Hard.java new file mode 100644 index 0000000..cafb0f8 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedPartitionSort_Hard.java @@ -0,0 +1,58 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class LinkedPartitionSort_Hard { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public Node partitionSort(Node head, int pr) { + if (head == null) { + return head; + } + Node cur = head; + int i = 0; + while (cur != null) { + i++; + cur = cur.next; + } + Node[] nodes = new Node[i]; + i = 0; + cur = head; + for (i = 0; i < nodes.length; i++) { + nodes[i] = cur; + cur = cur.next; + } + arrPartition(nodes, pr); + for (i = 1; i != nodes.length; i++) { + nodes[i - 1].next = nodes[i]; + } + nodes[i - 1].next = null; + return nodes[0]; + } + + public void arrPartition(Node[] nodes, int pr) { + int small = -1; + int big = nodes.length; + int index = 0; + while (index != big) { + if (nodes[index].value < pr) { + swap(nodes, ++small, index++); + } else if (nodes[index].value == pr) { + index++; + } else { + swap(nodes, --big, index); + } + } + } + + public void swap(Node[] nodes, int a, int b) { + Node tmp = nodes[a]; + nodes[a] = nodes[b]; + nodes[b] = tmp; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedRandomCopy.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedRandomCopy.java new file mode 100644 index 0000000..ebe262b --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedRandomCopy.java @@ -0,0 +1,45 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.HashMap; +import java.util.Map; + +public class LinkedRandomCopy { + public static class Node { + public int value; + public Node next; + public Node random; + + public Node(int value) { + this.value = value; + } + public Node next(Node node) { + next = node; + return this; + } + + public Node random(Node node) { + random = node; + return this; + } + } + + Map map = new HashMap<>(); + public Node copyRandomList(Node head) { + if(head == null) return null; + return dfs(head); + } + + Node dfs(Node node) { + if(node==null) { + return null; + } + if(map.containsKey(node)) { + return map.get(node); + } + Node copy = new Node(node.value); + map.put(node, copy); + copy.next(dfs(node.next)); + copy.random(dfs(node.random)); + return copy; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseDouble.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseDouble.java new file mode 100644 index 0000000..a8f3017 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseDouble.java @@ -0,0 +1,40 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class LinkedReverseDouble { + public static class Node { + public int value; + public Node pre; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node reverseList(Node head) { + Node pre = null; + Node next = null; + while (head != null) { + next = head.next; + head.next = pre; + head.pre = next; + pre = head; + head = next; + } + return pre; + } + + public static void main(String[] args) { + Node head = new Node(-1); + Node dummy = head; + Node pre = null; + for (int i = 0; i < 5; i++) { + dummy.pre = pre; + dummy.next = new Node(i); + pre = dummy; + dummy = dummy.next; + } + Node reverseNode = reverseList(head); + System.out.println(reverseNode); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseK1.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseK1.java new file mode 100644 index 0000000..c94f65e --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseK1.java @@ -0,0 +1,50 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class LinkedReverseK1 { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node reverseKNode(Node head, int k) { + if (k < 2) { + return head; + } + Stack stack = new Stack<>(); + Node newHead = head; + Node cur = head; + Node pre = null; + Node next = null; + while (cur != null) { + next = cur.next; + stack.push(cur); + if (stack.size() == k) { + pre = resign(stack, pre, next); + newHead = newHead == head ? cur : newHead; + } + cur = next; + } + return newHead; + } + + public static Node resign(Stack stack, Node left, Node right) { + Node cur = stack.pop(); + if (left != null) { + left.next = cur; + } + Node next = null; + while (!stack.isEmpty()) { + next = stack.pop(); + cur.next = next; + cur = next; + } + cur.next = right; + return cur; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseK2.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseK2.java new file mode 100644 index 0000000..be327bf --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseK2.java @@ -0,0 +1,54 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class LinkedReverseK2 { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node reverseKNode(Node head, int k) { + if (k < 2) { + return head; + } + Node cur = head; + Node start = null; + Node pre = null; + Node next = null; + int count = 1; + while (cur != null) { + next = cur.next; + if (count == k) { + start = pre == null ? head : pre.next; + head = pre == null ? cur : head; + resign(pre, start, cur, next); + pre = start; + count = 0; + } + count++; + cur = next; + } + return head; + } + + public static void resign(Node left, Node start, Node end, Node right) { + Node pre = start; + Node cur = start.next; + Node next = null; + while (cur != right) { + next = cur.next; + cur.next = pre; + pre = cur; + cur = next; + } + if (left != null) { + left.next = end; + } + start.next = right; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReversePart.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReversePart.java new file mode 100644 index 0000000..fef5fae --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReversePart.java @@ -0,0 +1,55 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class LinkedReversePart { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node reversePart(Node head, int from, int to) { + int len = 0; + Node node1 = head; + Node fNode = null; + Node tNode = null; + while (node1 != null) { + len++; + fNode = len == from - 1 ? node1 : fNode; + tNode = len == to + 1 ? node1 : tNode; + node1 = node1.next; + } + if (from > to || from < 1 || to > len || (to - from < 2)) { + return head; + } + node1 = fNode == null ? head : fNode.next; + Node node2 = node1.next; + node1.next = tNode; + Node next = null; + while (node2 != tNode) { + next = node2.next; + node2.next = node1; + node1 = node2; + node2 = next; + } + if (fNode != null) { + fNode.next = node1; + return head; + } + return node1; + } + + public static void main(String[] args) { + Node head = new Node(-1); + Node cur = head; + for (int i = 0; i < 5; i++) { + cur.next = new Node(i); + cur = cur.next; + } + Node reverseNode = reversePart(head, 1, 5); + System.out.println(reverseNode); + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseSingle.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseSingle.java new file mode 100644 index 0000000..bd14f8f --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedReverseSingle.java @@ -0,0 +1,35 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class LinkedReverseSingle { + public static class Node{ + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node reverseList(Node head) { + Node pre = null; + Node next = null; + while (head != null) { + next = head.next; + head.next = pre; + pre = head; + head = next; + } + return pre; + } + + public static void main(String[] args) { + Node head = new Node(-1); + Node cur = head; + for (int i = 0; i < 5; i++) { + cur.next = new Node(i); + cur = cur.next; + } + Node reverseNode = reverseList(head); + System.out.println(reverseNode); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedTwoSingleAdd1.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedTwoSingleAdd1.java new file mode 100644 index 0000000..bf5db21 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedTwoSingleAdd1.java @@ -0,0 +1,59 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class LinkedTwoSingleAdd1 { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node addList(Node head1, Node head2) { + Stack s1 = new Stack<>(); + Stack s2 = new Stack<>(); + while (head1 != null) { + s1.push(head1.value); + head1 = head1.next; + } + while (head2 != null) { + s2.push(head2.value); + head2 = head2.next; + } + int ca = 0; + int n1 = 0; + int n2 = 0; + int n = 0; + Node node = null; + Node pre = null; + while (!s1.isEmpty() || !s2.isEmpty()) { + n1 = s1.isEmpty() ? 0 : s1.pop(); + n2 = s2.isEmpty() ? 0 : s2.pop(); + n = n1 + n2 + ca; + pre = node; + node = new Node(n % 10); + node.next = pre; + ca = n / 10; + } + if (ca == 1) { + pre = node; + node = new Node(ca); + node.next = pre; + } + return node; + } + + public static void main(String[] args) { + Node head = new Node(0); + Node cur = head; + for (int i = 1; i < 3; i++) { + cur.next = new Node(i); + cur = cur.next; + } + Node sum = addList(head,head); + System.out.println(sum); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedTwoSingleAdd2.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedTwoSingleAdd2.java new file mode 100644 index 0000000..1f240df --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/LinkedTwoSingleAdd2.java @@ -0,0 +1,69 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class LinkedTwoSingleAdd2 { + public static class Node { + public int value; + public Node next; + + public Node(int value) { + this.value = value; + } + } + + public static Node addList(Node head1, Node head2) { + head1 = reverseList(head1); + head2 = reverseList(head2); + int ca = 0; + int n1 = 0; + int n2 = 0; + int n = 0; + Node c1 = head1; + Node c2 = head2; + Node node = null; + Node pre = null; + while (c1 != null || c2 != null) { + n1 = c1 == null ? 0 : c1.value; + n2 = c2 == null ? 0 : c2.value; + n = n1 + n2 + ca; + pre = node; + node = new Node(n % 10); + node.next = pre; + ca = n / 10; + c1 = c1 == null ? c1 : c1.next; + c2 = c2 == null ? c2 : c2.next; + } + if (ca == 1) { + pre = node; + node = new Node(ca); + node.next = pre; + } + head1 = reverseList(head1); + head2 = reverseList(head2); + return node; + } + + public static Node reverseList(Node head) { + Node pre = null; + Node next = null; + while (head != null) { + next = head.next; + head.next = pre; + pre = head; + head = next; + } + return pre; + } + + public static void main(String[] args) { + Node head = new Node(0); + Node cur = head; + for (int i = 1; i < 3; i++) { + cur.next = new Node(i); + cur = cur.next; + } + Node sum = addList(head, head); + System.out.println(sum); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/QueueDogCat.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/QueueDogCat.java new file mode 100644 index 0000000..44a5f4a --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/QueueDogCat.java @@ -0,0 +1,90 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Queue; +import java.util.concurrent.LinkedBlockingDeque; + +public class QueueDogCat { + public class Pet { + private String type; + + public Pet(String type) { + this.type = type; + } + + public String getType() { + return this.type; + } + } + + public class Dog extends Pet { + public Dog() { + super("dog"); + } + } + + public class Cat extends Pet { + public Cat() { + super("cat"); + } + } + + public class PetEnterQueue { + private Pet pet; + private long count; + + public PetEnterQueue(Pet pet, long count) { + this.pet = pet; + this.count = count; + } + + public Pet getPet() { + return pet; + } + + public long getCount() { + return count; + } + + public String getPetType() { + return this.pet.type; + } + } + + private Queue dogQueue; + private Queue catQueue; + private long count; + + public QueueDogCat() { + this.dogQueue = new LinkedBlockingDeque<>(); + this.catQueue = new LinkedBlockingDeque<>(); + this.count = 0; + } + + public void add(Pet pet) { + if ("dog".equals(pet.type)) { + this.dogQueue.add(new PetEnterQueue(pet, System.currentTimeMillis())); + } else { + this.catQueue.add(new PetEnterQueue(pet, System.currentTimeMillis())); + } + } + + public Pet pollAll() { + if (!dogQueue.isEmpty() && !catQueue.isEmpty()) { + if (dogQueue.peek().getCount() < catQueue.peek().getCount()) { + return dogQueue.peek().pet; + } else { + return catQueue.peek().pet; + } + } else if (!catQueue.isEmpty()) { + return catQueue.peek().pet; + } else if (!dogQueue.isEmpty()) { + return dogQueue.peek().pet; + } else { + throw new RuntimeException("no pet"); + } + } + + public Dog pollDog(){ + return (Dog) dogQueue.peek().pet; + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree.java index 8a37745..a445cc1 100644 --- a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree.java +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree.java @@ -1,7 +1,5 @@ package com.hks.eightsortingalgorithms.nowcoder; -import org.junit.jupiter.api.Test; - /** * @Author: hekuangsheng * @Date: 2018/10/25 @@ -50,11 +48,4 @@ private TreeNode reConstructBinaryTree(int[] pre, int startPre, int endPre, int[ return root; } - @Test - public void test() { - int[] pre = {1, 2, 4, 7, 3, 5, 6, 8}; - int[] in = {4, 7, 2, 1, 5, 3, 8, 6}; - TreeNode treeNode = reConstructBinaryTree(pre, in); - } - } diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/SlideWindowMax.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/SlideWindowMax.java new file mode 100644 index 0000000..a4a2d1e --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/SlideWindowMax.java @@ -0,0 +1,36 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.LinkedList; + +public class SlideWindowMax { + + public static int[] getMaxWindow(int[] nums, int k) { + if (nums == null || k < 1 || nums.length < k) { + return null; + } + LinkedList qmax = new LinkedList<>(); + int[] res = new int[nums.length - k + 1]; + int index = 0; + for (int i = 0; i < nums.length; i++) { + while (!qmax.isEmpty() && nums[qmax.peekFirst()] <= nums[i]) { + qmax.pollLast(); + } + qmax.addLast(i); + if (qmax.peekFirst() == i - k) { + qmax.pollFirst(); + } + if (i >= k - 1) { + res[index++] = nums[qmax.pollFirst()]; + } + } + return res; + } + + public static void main(String[] args) { + int[] arr = new int[]{1,2,3,4,1,1,1,1,1,5}; + int[] res = getMaxWindow(arr,3); + for (int i = 0; i < res.length; i++) { + System.out.println(res[i]); + } + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackGetMin.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackGetMin.java new file mode 100644 index 0000000..ec143f5 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackGetMin.java @@ -0,0 +1,43 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +/** + * @author heks + * @description: TODO + * @date 2020/9/22 + */ +public class StackGetMin { + private Stack stackData; + private Stack stackMin; + + public StackGetMin() { + stackData = new Stack<>(); + stackMin = new Stack<>(); + } + + public void push(int num) { + stackData.push(num); + if (stackMin.empty() || num <= stackMin.peek()) { + stackMin.push(num); + } + } + + public int pop() { + if (stackData.empty()) { + throw new RuntimeException("your stack is empty"); + } + int pop = stackData.pop(); + if (pop == stackMin.peek()) { + stackMin.pop(); + } + return pop; + } + + public int getMin(){ + if(stackMin.empty()){ + throw new RuntimeException("your stack is empty"); + } + return stackMin.peek(); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackHanoi.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackHanoi.java new file mode 100644 index 0000000..c1c1d51 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackHanoi.java @@ -0,0 +1,6 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class StackHanoi { + + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackReverse.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackReverse.java new file mode 100644 index 0000000..5e34af0 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackReverse.java @@ -0,0 +1,34 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class StackReverse { + public static int getLastVal(Stack stack) { + int val = stack.pop(); + if (stack.empty()) { + return val; + } else { + int last = getLastVal(stack); + stack.push(val); + return last; + } + } + + public static void reverse(Stack stack) { + if (stack.empty()) { + return; + } + int i = getLastVal(stack); + reverse(stack); + stack.push(i); + } + + public static void main(String[] args) { + Stack stack = new Stack<>(); + stack.add(1); + stack.add(2); + stack.add(3); + reverse(stack); + System.out.println(stack); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackSortByAnother.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackSortByAnother.java new file mode 100644 index 0000000..ee2b3f8 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackSortByAnother.java @@ -0,0 +1,33 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class StackSortByAnother { + + public static void sortStackByStack(Stack stack) { + Stack help = new Stack<>(); + while (!stack.empty()) { + int tmp = stack.pop(); + while (!help.empty() && help.peek() < tmp) { + stack.push(help.pop()); + } + help.push(tmp); + } + while (!help.empty()){ + stack.push(help.pop()); + } + } + + public static void main(String[] args) { + Stack stack = new Stack<>(); + stack.add(1); + stack.add(2); + stack.add(4); + stack.add(5); + stack.add(6); + stack.add(3); + sortStackByStack(stack); + System.out.println(stack); + } + +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackToQueue.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackToQueue.java new file mode 100644 index 0000000..bfb3fb3 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/StackToQueue.java @@ -0,0 +1,26 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +import java.util.Stack; + +public class StackToQueue { + public Stack stackPush; + public Stack stackPop; + + public StackToQueue() { + stackPush = new Stack<>(); + stackPop = new Stack<>(); + } + + public void add(int val){ + stackPush.add(val); + } + + public Integer poll(){ + if(stackPop.empty()){ + while(!stackPush.empty()){ + stackPop.add(stackPush.pop()); + } + } + return stackPop.pop(); + } +} diff --git a/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/TreeMax.java b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/TreeMax.java new file mode 100644 index 0000000..e213592 --- /dev/null +++ b/java-algorithms/src/main/java/com/hks/eightsortingalgorithms/nowcoder/TreeMax.java @@ -0,0 +1,5 @@ +package com.hks.eightsortingalgorithms.nowcoder; + +public class TreeMax { + +} diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/EightSortingAlgorithmsApplication.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/EightSortingAlgorithmsApplication.class index 1bc586e..6a67c42 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/EightSortingAlgorithmsApplication.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/EightSortingAlgorithmsApplication.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/aspect/MethodTimeAspect.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/aspect/MethodTimeAspect.class index 53dfedc..848b561 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/aspect/MethodTimeAspect.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/aspect/MethodTimeAspect.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/search/BinarySearchController.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/search/BinarySearchController.class index 2ed2bc4..e2c8f82 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/search/BinarySearchController.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/search/BinarySearchController.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/BubbleAlgorithmsController.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/BubbleAlgorithmsController.class index 3462be6..26cdfb6 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/BubbleAlgorithmsController.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/BubbleAlgorithmsController.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/BucketAlgorithmsController.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/BucketAlgorithmsController.class index 8cf8243..d63209b 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/BucketAlgorithmsController.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/BucketAlgorithmsController.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/MergeAlgorithmsController.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/MergeAlgorithmsController.class index bfcfcdc..c85c5b8 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/MergeAlgorithmsController.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/MergeAlgorithmsController.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/QuickAlgorithmsController.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/QuickAlgorithmsController.class index 8a791b8..62e965f 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/QuickAlgorithmsController.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/QuickAlgorithmsController.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/SelectAlgorithmsController.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/SelectAlgorithmsController.class index 8c21649..cc48982 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/SelectAlgorithmsController.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/SelectAlgorithmsController.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/SelectHeapAlgorithmsController.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/SelectHeapAlgorithmsController.class index f200714..ae1909f 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/SelectHeapAlgorithmsController.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/SelectHeapAlgorithmsController.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/ShellAlgorithmsController.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/ShellAlgorithmsController.class index d304706..ce3d736 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/ShellAlgorithmsController.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/ShellAlgorithmsController.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/StraightInsertAlgorithmsController.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/StraightInsertAlgorithmsController.class index c244695..205f500 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/StraightInsertAlgorithmsController.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/controller/sort/StraightInsertAlgorithmsController.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/leetcode/TwoSum.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/leetcode/TwoSum.class index c5539d0..00173cf 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/leetcode/TwoSum.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/leetcode/TwoSum.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/search/BinarySearch.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/search/BinarySearch.class index 0cc85ee..368a802 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/search/BinarySearch.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/search/BinarySearch.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/search/impl/BinarySearchImpl.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/search/impl/BinarySearchImpl.class index 59e5149..e3778d1 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/search/impl/BinarySearchImpl.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/search/impl/BinarySearchImpl.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/BubbleAlgorithms.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/BubbleAlgorithms.class index cea2b82..037b843 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/BubbleAlgorithms.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/BubbleAlgorithms.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/BucketAlgorithms.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/BucketAlgorithms.class index e72fee4..5f2bb24 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/BucketAlgorithms.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/BucketAlgorithms.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/MergeAlgorithms.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/MergeAlgorithms.class index 599bdd1..85b4a65 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/MergeAlgorithms.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/MergeAlgorithms.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/QuickAlgorithms.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/QuickAlgorithms.class index 1cf58e5..9d35831 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/QuickAlgorithms.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/QuickAlgorithms.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/SelectAlgorithms.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/SelectAlgorithms.class index 0957c32..29df95e 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/SelectAlgorithms.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/SelectAlgorithms.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/SelectHeapAlgorithms.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/SelectHeapAlgorithms.class index d236ec8..48219dc 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/SelectHeapAlgorithms.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/SelectHeapAlgorithms.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/ShellAlgorithms.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/ShellAlgorithms.class index 48f591d..48fd82c 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/ShellAlgorithms.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/ShellAlgorithms.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/StraightInsertAlgorithms.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/StraightInsertAlgorithms.class index 207e201..3a72b40 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/StraightInsertAlgorithms.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/StraightInsertAlgorithms.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/BubbleAlgorithmsImpl.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/BubbleAlgorithmsImpl.class index a04657a..3726321 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/BubbleAlgorithmsImpl.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/BubbleAlgorithmsImpl.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/BucketAlgorithmsImpl.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/BucketAlgorithmsImpl.class index 64dbc24..38273a5 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/BucketAlgorithmsImpl.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/BucketAlgorithmsImpl.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/MergeAlgorithmsImpl.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/MergeAlgorithmsImpl.class index 4d19795..ef4b645 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/MergeAlgorithmsImpl.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/MergeAlgorithmsImpl.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/QuickAlgorithmsImpl.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/QuickAlgorithmsImpl.class index f783f85..61902b9 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/QuickAlgorithmsImpl.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/QuickAlgorithmsImpl.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/SelectAlgorithmsImpl.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/SelectAlgorithmsImpl.class index c3e39e2..a426dc8 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/SelectAlgorithmsImpl.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/SelectAlgorithmsImpl.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/SelectHeapAlgorithmsImpl.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/SelectHeapAlgorithmsImpl.class index 1833c37..c269dcf 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/SelectHeapAlgorithmsImpl.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/SelectHeapAlgorithmsImpl.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/ShellAlgorithmsImpl.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/ShellAlgorithmsImpl.class index a22350b..2228aa3 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/ShellAlgorithmsImpl.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/ShellAlgorithmsImpl.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/StraightInsertAlgorithmsImpl.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/StraightInsertAlgorithmsImpl.class index d68a645..f451eca 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/StraightInsertAlgorithmsImpl.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/method/sort/impl/StraightInsertAlgorithmsImpl.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree$TreeNode.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree$TreeNode.class index e71f2a2..03a658c 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree$TreeNode.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree$TreeNode.class differ diff --git a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree.class b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree.class index c51a5d2..212b855 100644 Binary files a/java-algorithms/target/classes/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree.class and b/java-algorithms/target/classes/com/hks/eightsortingalgorithms/nowcoder/RebuildBinaryTree.class differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/Agent/Agent.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/Agent/Agent.class deleted file mode 100644 index 7eae353..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/Agent/Agent.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/Agent/TestTransformer.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/Agent/TestTransformer.class deleted file mode 100644 index 961df62..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/Agent/TestTransformer.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/EnchaseTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/EnchaseTest.class deleted file mode 100644 index e45765e..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/EnchaseTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/EncodeTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/EncodeTest.class deleted file mode 100644 index 349016a..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/EncodeTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/FinallyDemo.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/FinallyDemo.class deleted file mode 100644 index 8e46740..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/FinallyDemo.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/PrecisionDemo.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/PrecisionDemo.class deleted file mode 100644 index bd7d142..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/PrecisionDemo.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/PrimitiveTypeTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/PrimitiveTypeTest.class deleted file mode 100644 index eeb0e90..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/PrimitiveTypeTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/QiangZhiZhuanHuan.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/QiangZhiZhuanHuan.class deleted file mode 100644 index 061c489..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/QiangZhiZhuanHuan.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/ZiDongLeiZhuan.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/ZiDongLeiZhuan.class deleted file mode 100644 index b1731ad..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/ZiDongLeiZhuan.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/aceessControler/MyFileInputStream.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/aceessControler/MyFileInputStream.class deleted file mode 100644 index 8fbc1fa..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/aceessControler/MyFileInputStream.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/aceessControler/MySecurityManager.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/aceessControler/MySecurityManager.class deleted file mode 100644 index a324778..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/aceessControler/MySecurityManager.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/aceessControler/TestMySecurityManager.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/aceessControler/TestMySecurityManager.class deleted file mode 100644 index d5a6239..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/aceessControler/TestMySecurityManager.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Apple.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Apple.class deleted file mode 100644 index a054ba5..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Apple.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Column.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Column.class deleted file mode 100644 index d177967..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Column.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitColor$Color.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitColor$Color.class deleted file mode 100644 index c37b763..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitColor$Color.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitColor.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitColor.class deleted file mode 100644 index c701bf3..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitColor.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitName.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitName.class deleted file mode 100644 index 92b2394..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitName.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitProvider.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitProvider.class deleted file mode 100644 index 57d78eb..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/FruitProvider.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Greeting$FontColor.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Greeting$FontColor.class deleted file mode 100644 index 3ce1182..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Greeting$FontColor.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Greeting.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Greeting.class deleted file mode 100644 index a3cbb8e..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Greeting.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/MyAnnotation.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/MyAnnotation.class deleted file mode 100644 index a4825c1..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/MyAnnotation.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/MyReflection.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/MyReflection.class deleted file mode 100644 index cdc3c24..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/MyReflection.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/MyTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/MyTest.class deleted file mode 100644 index 5bff9f3..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/MyTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/NoDBColumn.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/NoDBColumn.class deleted file mode 100644 index 5b4f260..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/NoDBColumn.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Table.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Table.class deleted file mode 100644 index 3424405..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Table.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Test.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Test.class deleted file mode 100644 index 164b220..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/annotation/Test.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/AopClassAdapter.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/AopClassAdapter.class deleted file mode 100644 index 42364da..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/AopClassAdapter.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/AopInteceptor.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/AopInteceptor.class deleted file mode 100644 index 781a8ed..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/AopInteceptor.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/AopMethodVisitor.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/AopMethodVisitor.class deleted file mode 100644 index 9022611..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/AopMethodVisitor.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/HelloGeneratorClass.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/HelloGeneratorClass.class deleted file mode 100644 index 068d99a..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/HelloGeneratorClass.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/MyClassLoader.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/MyClassLoader.class deleted file mode 100644 index 6167260..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/asm/MyClassLoader.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/builder/BuilderTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/builder/BuilderTest.class deleted file mode 100644 index ab7444d..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/builder/BuilderTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/builder/User$Builder.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/builder/User$Builder.class deleted file mode 100644 index 029c89e..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/builder/User$Builder.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/builder/User.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/builder/User.class deleted file mode 100644 index 75f892c..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/builder/User.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap$1.class deleted file mode 100644 index a647c34..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap$CheckTimeThread.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap$CheckTimeThread.class deleted file mode 100644 index 2e3874d..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap$CheckTimeThread.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap$Node.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap$Node.class deleted file mode 100644 index 9f8a03e..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap$Node.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap.class deleted file mode 100644 index 13cd37f..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUAbstractMap.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRULinkedMap$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRULinkedMap$1.class deleted file mode 100644 index 69b9bb3..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRULinkedMap$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRULinkedMap.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRULinkedMap.class deleted file mode 100644 index b6b29b2..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRULinkedMap.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUMap$Node.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUMap$Node.class deleted file mode 100644 index 6a9e6e5..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUMap$Node.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUMap.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUMap.class deleted file mode 100644 index cf395ac..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cache/LRUMap.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/classLoader/MyClassLoader.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/classLoader/MyClassLoader.class deleted file mode 100644 index 28f815c..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/classLoader/MyClassLoader.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/classLoader/TestBeLoader.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/classLoader/TestBeLoader.class deleted file mode 100644 index 10be1cc..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/classLoader/TestBeLoader.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/classLoader/TestClassLoaderDemo.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/classLoader/TestClassLoaderDemo.class deleted file mode 100644 index a2aca02..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/classLoader/TestClassLoaderDemo.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/Person.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/Person.class deleted file mode 100644 index 7a4cb32..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/Person.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy$Body.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy$Body.class deleted file mode 100644 index c9b1e5f..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy$Body.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy$Face.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy$Face.class deleted file mode 100644 index 7ef42e1..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy$Face.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy$Head.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy$Head.class deleted file mode 100644 index 6da0688..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy$Head.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy.class deleted file mode 100644 index b7b7ac6..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/RealCopy.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/ReferenceCopy.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/ReferenceCopy.class deleted file mode 100644 index 2f35c3c..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/cloneClass/ReferenceCopy.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$1.class deleted file mode 100644 index ee0be4e..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$2.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$2.class deleted file mode 100644 index 98e1c85..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$2.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$3.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$3.class deleted file mode 100644 index 76474b9..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$3.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$4.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$4.class deleted file mode 100644 index ee0a31c..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare$4.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare.class deleted file mode 100644 index 009e4d6..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/compare/MapCompare.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/conllectors/IteratorFor.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/conllectors/IteratorFor.class deleted file mode 100644 index 3f369c1..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/conllectors/IteratorFor.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/AntStatus.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/AntStatus.class deleted file mode 100644 index f30ad62..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/AntStatus.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumClassTest$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumClassTest$1.class deleted file mode 100644 index d489f8d..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumClassTest$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumClassTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumClassTest.class deleted file mode 100644 index f9bd53b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumClassTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumMapSample$Size.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumMapSample$Size.class deleted file mode 100644 index f8816d1..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumMapSample$Size.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumMapSample.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumMapSample.class deleted file mode 100644 index 9bb39d4..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/EnumMapSample.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Grade.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Grade.class deleted file mode 100644 index d84309c..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Grade.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample$Size.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample$Size.class deleted file mode 100644 index 0f840ed..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample$Size.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample.class deleted file mode 100644 index 3435434..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample2$Size.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample2$Size.class deleted file mode 100644 index 1ff4b2b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample2$Size.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample2.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample2.class deleted file mode 100644 index 1b9035f..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample2.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$1.class deleted file mode 100644 index 5f2cd9f..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size$1.class deleted file mode 100644 index ae4b7b2..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size$2.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size$2.class deleted file mode 100644 index af21319..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size$2.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size$3.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size$3.class deleted file mode 100644 index 5534a2e..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size$3.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size.class deleted file mode 100644 index 81ec04c..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3$Size.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3.class deleted file mode 100644 index 5bafb3d..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Sample3.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Student.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Student.class deleted file mode 100644 index 2e482fd..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/enumClass/Student.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/Fish.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/Fish.class deleted file mode 100644 index 7e33638..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/Fish.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/Food.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/Food.class deleted file mode 100644 index 7133138..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/Food.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/FoodFactory.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/FoodFactory.class deleted file mode 100644 index e2fc27b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/FoodFactory.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/FoodFactoryTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/FoodFactoryTest.class deleted file mode 100644 index 61aa3d8..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/FoodFactoryTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/Fruit.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/Fruit.class deleted file mode 100644 index 698db4d..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/Fruit.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/SingletonClass$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/SingletonClass$1.class deleted file mode 100644 index 6b9070e..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/SingletonClass$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/SingletonClass$SingleHolder.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/SingletonClass$SingleHolder.class deleted file mode 100644 index 0c08c74..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/SingletonClass$SingleHolder.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/SingletonClass.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/SingletonClass.class deleted file mode 100644 index c89bfdd..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/SingletonClass.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/StaticFactoryClass.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/StaticFactoryClass.class deleted file mode 100644 index e821573..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/factory/StaticFactoryClass.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/finalClass/FinalTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/finalClass/FinalTest.class deleted file mode 100644 index c914736..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/finalClass/FinalTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/Animal.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/Animal.class deleted file mode 100644 index 688b8a1..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/Animal.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/Content.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/Content.class deleted file mode 100644 index 3c42c72..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/Content.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/Dog.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/Dog.class deleted file mode 100644 index 3059efe..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/Dog.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/RelationTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/RelationTest.class deleted file mode 100644 index ecc21a7..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/genericity/RelationTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashcode/EqualsTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashcode/EqualsTest.class deleted file mode 100644 index b381cf2..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashcode/EqualsTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashcode/MapEqualstest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashcode/MapEqualstest.class deleted file mode 100644 index 2a05173..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashcode/MapEqualstest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashcode/Person.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashcode/Person.class deleted file mode 100644 index 869cd29..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashcode/Person.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashmap/A.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashmap/A.class deleted file mode 100644 index 282743b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashmap/A.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashmap/HashMapKeyTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashmap/HashMapKeyTest.class deleted file mode 100644 index bd05c94..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashmap/HashMapKeyTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashmap/LinkedHashMapTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashmap/LinkedHashMapTest.class deleted file mode 100644 index 7038a19..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/hashmap/LinkedHashMapTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/jUnitPerf/DemoServiceTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/jUnitPerf/DemoServiceTest.class deleted file mode 100644 index 3bf5ed1..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/jUnitPerf/DemoServiceTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/FilterTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/FilterTest.class deleted file mode 100644 index 9e9ded5..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/FilterTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/FindFirstTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/FindFirstTest.class deleted file mode 100644 index 6dc6d72..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/FindFirstTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/LimitSkipTest$Person.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/LimitSkipTest$Person.class deleted file mode 100644 index 348d292..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/LimitSkipTest$Person.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/LimitSkipTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/LimitSkipTest.class deleted file mode 100644 index 4065c3f..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/LimitSkipTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/MapReflectTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/MapReflectTest.class deleted file mode 100644 index 423914b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/MapReflectTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/MatchTest$Person.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/MatchTest$Person.class deleted file mode 100644 index b67fe37..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/MatchTest$Person.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/MatchTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/MatchTest.class deleted file mode 100644 index 747948a..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/MatchTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/PeekTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/PeekTest.class deleted file mode 100644 index 7740cd6..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/PeekTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/ReduceTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/ReduceTest.class deleted file mode 100644 index 010dd1b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lambda/ReduceTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/Test.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/Test.class deleted file mode 100644 index f0c210a..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/Test.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/reentrant/ReentrantTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/reentrant/ReentrantTest.class deleted file mode 100644 index d7b38b8..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/reentrant/ReentrantTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/reentrant/SynchronizedTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/reentrant/SynchronizedTest.class deleted file mode 100644 index 827cd3c..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/reentrant/SynchronizedTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLock.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLock.class deleted file mode 100644 index 775b2a2..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLock.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLock1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLock1.class deleted file mode 100644 index 0a76b6b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLock1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLock1Test.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLock1Test.class deleted file mode 100644 index 80a0bd1..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLock1Test.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLockTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLockTest.class deleted file mode 100644 index 0b7eafc..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/lock/spinLock/SpinLockTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/BigObj2Old.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/BigObj2Old.class deleted file mode 100644 index 0df62b2..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/BigObj2Old.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/EqualsOOMTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/EqualsOOMTest.class deleted file mode 100644 index 9b0e788..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/EqualsOOMTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/GCTimeTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/GCTimeTest.class deleted file mode 100644 index 63828cd..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/GCTimeTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/HeapSize.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/HeapSize.class deleted file mode 100644 index 0485eac..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/HeapSize.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/MaxTenuringThreshold.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/MaxTenuringThreshold.class deleted file mode 100644 index 00bcc01..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/MaxTenuringThreshold.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/PutInEden.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/PutInEden.class deleted file mode 100644 index 4c21f82..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/PutInEden.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/PutInEden2.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/PutInEden2.class deleted file mode 100644 index cdde720..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/PutInEden2.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/ReferenceTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/ReferenceTest.class deleted file mode 100644 index 97c8f34..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/oom/ReferenceTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/UserService.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/UserService.class deleted file mode 100644 index 9943f0a..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/UserService.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/UserServiceImpl.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/UserServiceImpl.class deleted file mode 100644 index 9298bbb..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/UserServiceImpl.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/cglib/CglibProxyTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/cglib/CglibProxyTest.class deleted file mode 100644 index c3adbe6..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/cglib/CglibProxyTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/cglib/MyMethodInterceptor.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/cglib/MyMethodInterceptor.class deleted file mode 100644 index d0c2f3f..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/cglib/MyMethodInterceptor.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/jdk/JDKProxyTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/jdk/JDKProxyTest.class deleted file mode 100644 index 7683ce4..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/jdk/JDKProxyTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/jdk/MyInvocationHandler.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/jdk/MyInvocationHandler.class deleted file mode 100644 index 300026d..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/proxy/jdk/MyInvocationHandler.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/recall/Solution.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/recall/Solution.class deleted file mode 100644 index 2e232d9..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/recall/Solution.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/CompileScript.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/CompileScript.class deleted file mode 100644 index 76c5c8a..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/CompileScript.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/FirstJavaScript.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/FirstJavaScript.class deleted file mode 100644 index 4f3eb97..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/FirstJavaScript.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/InterfaceTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/InterfaceTest.class deleted file mode 100644 index 77cf70b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/InterfaceTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/InvocableTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/InvocableTest.class deleted file mode 100644 index 8be959d..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/InvocableTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/ListScriptEngines.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/ListScriptEngines.class deleted file mode 100644 index 1dbfb85..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/ListScriptEngines.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/ReverseString.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/ReverseString.class deleted file mode 100644 index a2d8224..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/script/ReverseString.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/securityManager/MySecurityManager.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/securityManager/MySecurityManager.class deleted file mode 100644 index 1fee6a3..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/securityManager/MySecurityManager.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/securityManager/TestMySecurityManager.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/securityManager/TestMySecurityManager.class deleted file mode 100644 index 44b92f9..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/securityManager/TestMySecurityManager.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/serializable/DeserializeDemo.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/serializable/DeserializeDemo.class deleted file mode 100644 index db82417..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/serializable/DeserializeDemo.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/serializable/Employee.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/serializable/Employee.class deleted file mode 100644 index 0da3769..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/serializable/Employee.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/serializable/SerializeDemo.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/serializable/SerializeDemo.class deleted file mode 100644 index 91fca5f..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/serializable/SerializeDemo.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Doer.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Doer.class deleted file mode 100644 index a443c82..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Doer.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Friend$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Friend$1.class deleted file mode 100644 index c20f95e..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Friend$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Friend.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Friend.class deleted file mode 100644 index 58b4dbb..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Friend.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Stranger$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Stranger$1.class deleted file mode 100644 index bd1623c..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Stranger$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Stranger.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Stranger.class deleted file mode 100644 index 3fe376c..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/Stranger.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/TextFileDisplayer.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/TextFileDisplayer.class deleted file mode 100644 index 1e99870..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/stackAccess/TextFileDisplayer.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Base.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Base.class deleted file mode 100644 index 4491508..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Base.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/MyClass.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/MyClass.class deleted file mode 100644 index 01fc029..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/MyClass.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Person.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Person.class deleted file mode 100644 index 2d52bc2..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Person.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Test.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Test.class deleted file mode 100644 index 0f5b29b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Test.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Test2.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Test2.class deleted file mode 100644 index d556a16..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/Test2.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/ThisClass.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/ThisClass.class deleted file mode 100644 index c7ae663..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/staticClass/ThisClass.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/AsyncIOTask.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/AsyncIOTask.class deleted file mode 100644 index 746d72f..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/AsyncIOTask.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/PoolSizeCalculator$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/PoolSizeCalculator$1.class deleted file mode 100644 index 148d56b..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/PoolSizeCalculator$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/PoolSizeCalculator.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/PoolSizeCalculator.class deleted file mode 100644 index e18b390..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/PoolSizeCalculator.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/SimplePoolSizeCaculator.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/SimplePoolSizeCaculator.class deleted file mode 100644 index f00d940..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/SimplePoolSizeCaculator.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/TestThreadPool$Task.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/TestThreadPool$Task.class deleted file mode 100644 index 3953562..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/TestThreadPool$Task.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/TestThreadPool.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/TestThreadPool.class deleted file mode 100644 index 5b31c34..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/TestThreadPool.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/ThreadPool$1.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/ThreadPool$1.class deleted file mode 100644 index 83bee22..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/ThreadPool$1.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/ThreadPool$WorkThread.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/ThreadPool$WorkThread.class deleted file mode 100644 index be1c03d..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/ThreadPool$WorkThread.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/ThreadPool.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/ThreadPool.class deleted file mode 100644 index 3337198..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/threadpool/ThreadPool.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/valuePass/Person.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/valuePass/Person.class deleted file mode 100644 index 8e32876..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/valuePass/Person.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/valuePass/RefrencePassTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/valuePass/RefrencePassTest.class deleted file mode 100644 index d4fb2ab..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/valuePass/RefrencePassTest.class and /dev/null differ diff --git a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/valuePass/ValuePassTest.class b/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/valuePass/ValuePassTest.class deleted file mode 100644 index d43b234..0000000 Binary files a/java-algorithms/target/test-classes/com/hks/eightsortingalgorithms/valuePass/ValuePassTest.class and /dev/null differ diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Apple.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Apple.java new file mode 100644 index 0000000..951c7a5 --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Apple.java @@ -0,0 +1,29 @@ +package com.hks.annotation; + +public class Apple { + + @FruitName("Apple") + private String appleName; + + @FruitColor(fruitColor= FruitColor.Color.RED) + private String appleColor; + + public void setAppleColor(String appleColor) { + this.appleColor = appleColor; + } + public String getAppleColor() { + return appleColor; + } + + public void setAppleName(String appleName) { + this.appleName = appleName; + } + + public String getAppleName() { + return appleName; + } + + public void displayName(){ + System.out.println("水果的名字是：苹果"); + } +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Column.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Column.java new file mode 100644 index 0000000..bffaf5f --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Column.java @@ -0,0 +1,31 @@ +package com.hks.annotation; + +import java.lang.annotation.*; + +/** + * @Retention定义了该Annotation被保留的时间长短： + * 某些Annotation仅出现在源代码中，而被编译器丢弃； + * 而另一些却被编译在class文件中； + * 编译在class文件中的Annotation可能会被虚拟机忽略，而另一些在class被装载时将被读取 + * （请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。 + * 使用这个meta-Annotation可以对 Annotation的“生命周期”限制。 + * + *取值（RetentionPoicy）有： + +　　　　1.SOURCE:在源文件中有效（即源文件保留） +　　　　2.CLASS:在class文件中有效（即class保留） +　　　　3.RUNTIME:在运行时有效（即运行时保留） + */ +@Target(ElementType.TYPE) +///Column注解的的RetentionPolicy的属性值是RUTIME,这样注解处理器可以通过反射，获取到该注解的属性值，从而去做一些运行时的逻辑处理 +@Retention(RetentionPolicy.RUNTIME) +///@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。 +@Documented +public @interface Column { + + String name() default "fieldName"; + String setFuncName() default "setField"; + String getFuncName() default "getField"; + boolean defaultDBValue() default false; + +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/FruitColor.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/FruitColor.java new file mode 100644 index 0000000..259b247 --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/FruitColor.java @@ -0,0 +1,21 @@ +package com.hks.annotation; + +import java.lang.annotation.*; + +@Target(ElementType.FIELD) +@Retention(RetentionPolicy.RUNTIME) +@Documented +public @interface FruitColor { + /** + * 颜色枚举 + * @author peida + * + */ + public enum Color{ BULE,RED,GREEN}; + + /** + * 颜色属性 + * @return + */ + Color fruitColor() default Color.GREEN; +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/FruitName.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/FruitName.java new file mode 100644 index 0000000..6c650cd --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/FruitName.java @@ -0,0 +1,10 @@ +package com.hks.annotation; + +import java.lang.annotation.*; + +@Target(ElementType.FIELD) +@Retention(RetentionPolicy.RUNTIME) +@Documented +public @interface FruitName { + String value() default ""; +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/FruitProvider.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/FruitProvider.java new file mode 100644 index 0000000..1fdf50f --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/FruitProvider.java @@ -0,0 +1,31 @@ +package com.hks.annotation; + +import java.lang.annotation.*; + +/** + * 水果供应者注解 + * @author peida + * + */ +@Target(ElementType.FIELD) +@Retention(RetentionPolicy.RUNTIME) +@Documented +public @interface FruitProvider { + /** + * 供应商编号 + * @return + */ + int id() default -1; + + /** + * 供应商名称 + * @return + */ + String name() default ""; + + /** + * 供应商地址 + * @return + */ + String address() default ""; +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Greeting.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Greeting.java new file mode 100644 index 0000000..46348ca --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Greeting.java @@ -0,0 +1,20 @@ +package com.hks.annotation; + + +import java.lang.annotation.Inherited; + +/** + * @Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。 + * 如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。 + +　　注意：@Inherited annotation类型是被标注过的class的子类所继承。 + 类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。 + */ +@Inherited +public @interface Greeting { + + enum FontColor{ BULE,RED,GREEN}; + String name(); + FontColor fontColor() default FontColor.GREEN; + +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/MyAnnotation.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/MyAnnotation.java new file mode 100644 index 0000000..eb4855e --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/MyAnnotation.java @@ -0,0 +1,16 @@ +package com.hks.annotation; + + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface MyAnnotation +{ + + String hello () default "hello"; + String world(); +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/MyReflection.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/MyReflection.java new file mode 100644 index 0000000..b53eada --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/MyReflection.java @@ -0,0 +1,36 @@ +package com.hks.annotation; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Method; + +/** + * 用反射机制来调用注解中的内容 + */ +public class MyReflection { + + public static void main(String[] args) throws Exception + { + // 获得要调用的类 + Class myTestClass = MyTest.class; + // 获得要调用的方法，output是要调用的方法名字，new Class[]{}为所需要的参数。空则不是这种 + Method method = myTestClass.getMethod("output", new Class[]{}); + // 是否有类型为MyAnnotation的注解 + if (method.isAnnotationPresent(MyAnnotation.class)) + { + // 获得注解 + MyAnnotation annotation = method.getAnnotation(MyAnnotation.class); + // 调用注解的内容 + System.out.println(annotation.hello()); + System.out.println(annotation.world()); + } + System.out.println("----------------------------------"); + // 获得所有注解。必须是runtime类型的 + Annotation[] annotations = method.getAnnotations(); + for (Annotation annotation : annotations) + { + // 遍历所有注解的名字 + System.out.println(annotation.annotationType().getName()); + } + } + +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/MyTest.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/MyTest.java new file mode 100644 index 0000000..03159c1 --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/MyTest.java @@ -0,0 +1,10 @@ +package com.hks.annotation; + +public class MyTest { + + @MyAnnotation(hello = "Hello,Beijing",world = "Hello,world") + public void output() { + System.out.println("method output is running "); + } + +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/NoDBColumn.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/NoDBColumn.java new file mode 100644 index 0000000..2ec8533 --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/NoDBColumn.java @@ -0,0 +1,11 @@ +package com.hks.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +/** + * 注解Table 可以用于注解类、接口(包括注解类型) 或enum声明,而注解NoDBColumn仅可用于注解类的成员变量。 + */ +@Target(ElementType.FIELD) +public @interface NoDBColumn { +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Table.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Table.java new file mode 100644 index 0000000..f00ce04 --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Table.java @@ -0,0 +1,33 @@ +package com.hks.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +/** + * @Target说明了Annotation所修饰的对象范围：Annotation可被用于 + * packages、types（类、接口、枚举、Annotation类型）、 + * 类型成员（方法、构造方法、成员变量、枚举值）、 + * 方法参数和本地变量（如循环变量、catch参数）。 + * + * 在Annotation类型的声明中使用了target可更加明晰其修饰的目标。 + * + * 取值(ElementType)有： + +　　　　1.CONSTRUCTOR:用于描述构造器 +　　　　2.FIELD:用于描述域 +　　　　3.LOCAL_VARIABLE:用于描述局部变量 +　　　　4.METHOD:用于描述方法 +　　　　5.PACKAGE:用于描述包 +　　　　6.PARAMETER:用于描述参数 +　　　　7.TYPE:用于描述类、接口(包括注解类型) 或enum声明 + */ +@Target(ElementType.TYPE) +public @interface Table { + + /** + * 数据表名称注解，默认值为类名称 + * @return + */ + String tableName() default "className"; + +} diff --git a/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Test.java b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Test.java new file mode 100644 index 0000000..f8a88d7 --- /dev/null +++ b/java-annotation/delombok/src-bak/src/main/java/com/hks/annotation/Test.java @@ -0,0 +1,17 @@ +package com.hks.annotation; + +@Column(name = "heks",setFuncName = "heksFunc") + +public class Test { + + @FruitColor + private String colnum; + + @org.junit.Test + public void test(){ + Apple apple = new Apple(); + System.out.print(apple.getAppleColor()); + System.out.print(apple.getAppleName()); + } + +} diff --git a/java-annotation/pom.xml b/java-annotation/pom.xml index 81b7dd4..945cc40 100644 --- a/java-annotation/pom.xml +++ b/java-annotation/pom.xml @@ -7,6 +7,14 @@ com.hks java-annotation 1.0-SNAPSHOT + + + junit + junit + 4.13.1 + compile + + + - \ No newline at end of file diff --git a/java-aspect/delombok/src-bak/src/main/java/com/hks/agent/Agent.java b/java-aspect/delombok/src-bak/src/main/java/com/hks/agent/Agent.java new file mode 100644 index 0000000..68afc2c --- /dev/null +++ b/java-aspect/delombok/src-bak/src/main/java/com/hks/agent/Agent.java @@ -0,0 +1,20 @@ +package com.hks.agent; + +import java.lang.instrument.Instrumentation; + +/** + * Agent 类必须打成jar包，然后里面的 META-INF/MAINIFEST.MF 必须包含 Premain-Class这个属性。 + 下面是一个MANIFEST.MF的例子： + --------------------- + Manifest-Version: 1.0 + Premain-Class:MyAgent1 + Created-By:1.6.0_06 + --------------------- + 然后把MANIFEST.MF 加入到你的jar包中。 + */ +public class Agent { + public static void premain(String args, Instrumentation inst){ + System.out.println("Hi, I'm agent!"); + inst.addTransformer(new TestTransformer()); + } +} diff --git a/java-aspect/delombok/src-bak/src/main/java/com/hks/agent/TestTransformer.java b/java-aspect/delombok/src-bak/src/main/java/com/hks/agent/TestTransformer.java new file mode 100644 index 0000000..c0c2456 --- /dev/null +++ b/java-aspect/delombok/src-bak/src/main/java/com/hks/agent/TestTransformer.java @@ -0,0 +1,40 @@ +package com.hks.agent; + +import java.lang.instrument.ClassFileTransformer; +import java.lang.instrument.IllegalClassFormatException; +import java.security.ProtectionDomain; + +import jdk.internal.org.objectweb.asm.ClassReader; +import jdk.internal.org.objectweb.asm.ClassWriter; +import jdk.internal.org.objectweb.asm.Opcodes; +import jdk.internal.org.objectweb.asm.tree.*; + +public class TestTransformer implements ClassFileTransformer { + + public byte[] transform(ClassLoader arg0, String arg1, Class arg2, + ProtectionDomain arg3, byte[] arg4) + throws IllegalClassFormatException { + ClassReader cr = new ClassReader(arg4); + ClassNode cn = new ClassNode(); + cr.accept(cn, 0); + for (Object obj : cn.methods) { + MethodNode md = (MethodNode) obj; + if ("".endsWith(md.name) || "".equals(md.name)) { + continue; + } + InsnList insns = md.instructions; + InsnList il = new InsnList(); + il.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/System", + "out", "Ljava/io/PrintStream;")); + il.add(new LdcInsnNode("Enter method-> " + cn.name+"."+md.name)); + il.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, + "java/io/PrintStream", "println", "(Ljava/lang/String;)V")); + insns.insert(il); + md.maxStack += 3; + } + ClassWriter cw = new ClassWriter(0); + cn.accept(cw); + return cw.toByteArray(); + } +} + diff --git a/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/AopClassAdapter.java b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/AopClassAdapter.java new file mode 100644 index 0000000..cf821e9 --- /dev/null +++ b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/AopClassAdapter.java @@ -0,0 +1,26 @@ +package com.hks.asm; + +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +/** + * 用来处理哪些方法需要进行修改 + */ +public class AopClassAdapter extends ClassVisitor implements Opcodes { + + public AopClassAdapter(int api, ClassVisitor cv) { + super(api, cv); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions); + // 对test开头的方法进行特殊处理 + if (name.startsWith("test")) { + mv = new AopMethodVisitor(this.api, mv); + } + return mv; + } + +} diff --git a/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/AopInteceptor.java b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/AopInteceptor.java new file mode 100644 index 0000000..1aee3e3 --- /dev/null +++ b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/AopInteceptor.java @@ -0,0 +1,18 @@ +package com.hks.asm; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/19 + */ +public class AopInteceptor { + + public static void before(){ + System.out.println(".......before()......."); + } + + public static void after(){ + System.out.println(".......after()......."); + } + + +} diff --git a/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/AopMethodVisitor.java b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/AopMethodVisitor.java new file mode 100644 index 0000000..e630c76 --- /dev/null +++ b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/AopMethodVisitor.java @@ -0,0 +1,31 @@ +package com.hks.asm; + +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +/** + * @Author: hekuangsheng + * @Date: 2018/10/19 + * + * 修改字节码 + */ +public class AopMethodVisitor extends MethodVisitor implements Opcodes { + + public AopMethodVisitor(int api, MethodVisitor mv) { + super(api, mv); + } + + @Override + public void visitCode() { + super.visitCode(); + this.visitMethodInsn(INVOKESTATIC, "com/hks/asm/AopInteceptor", "before", "()V", false); + } + + @Override + public void visitInsn(int opcode) { + if (opcode >= IRETURN && opcode <= RETURN) + // 在返回之前安插after 代码。 + this.visitMethodInsn(INVOKESTATIC, "com/hks/asm/AopInteceptor", "after", "()V", false); + super.visitInsn(opcode); + } + +} diff --git a/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/HelloGeneratorClass.java b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/HelloGeneratorClass.java new file mode 100644 index 0000000..1ef7d94 --- /dev/null +++ b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/HelloGeneratorClass.java @@ -0,0 +1,262 @@ +package com.hks.asm; + +import org.junit.Test; +import org.objectweb.asm.*; + +import java.io.File; +import java.io.FileOutputStream; +import java.lang.reflect.Method; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/19 + * + * 通过asm动态生成java类，测试的main方法也在这里 + */ +public class HelloGeneratorClass implements Opcodes { + + /** + * 使用构造Hello类class字节码
+ * package中的Hello.java只是代码原型，本例中只供对比用，没有实际使用到这个类。
+ * ASM代码生成工具使用 bytecode + * + * @return + * @throws Exception + */ + public static byte[] generatorHelloClass() throws Exception { + + ClassWriter cw = new ClassWriter(0); + FieldVisitor fv; + MethodVisitor mv; + + cw.visit(V1_7, ACC_PUBLIC + ACC_SUPER, "com/hks/asm/Hello", null, "java/lang/Object", null); + + cw.visitSource("Hello.java", null); + + { + fv = cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "FLAG", "Ljava/lang/String;", null, + "\u6211\u662f\u5e38\u91cf"); + fv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC, "", "()V", null, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V", false); + mv.visitInsn(RETURN); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitMaxs(1, 1); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC, "display", "()V", null, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitInsn(ICONST_0); + mv.visitVarInsn(ISTORE, 1); + Label l1 = new Label(); + mv.visitLabel(l1); + Label l2 = new Label(); + mv.visitJumpInsn(GOTO, l2); + Label l3 = new Label(); + mv.visitLabel(l3); + mv.visitFrame(Opcodes.F_APPEND, 1, new Object[] { Opcodes.INTEGER }, 0, null); + mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); + mv.visitLdcInsn(">>>>>>>>>>\u6211\u662f\u5e38\u91cf"); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false); + Label l4 = new Label(); + mv.visitLabel(l4); + mv.visitIincInsn(1, 1); + mv.visitLabel(l2); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitVarInsn(ILOAD, 1); + mv.visitIntInsn(BIPUSH, 8); + mv.visitJumpInsn(IF_ICMPLT, l3); + Label l5 = new Label(); + mv.visitLabel(l5); + mv.visitInsn(RETURN); + Label l6 = new Label(); + mv.visitLabel(l6); + mv.visitMaxs(2, 2); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC, "testList", "()Ljava/util/List;", "()Ljava/util/List;", + null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitTypeInsn(NEW, "java/util/ArrayList"); + mv.visitInsn(DUP); + mv.visitMethodInsn(INVOKESPECIAL, "java/util/ArrayList", "", "()V", false); + mv.visitVarInsn(ASTORE, 1); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitVarInsn(ALOAD, 1); + mv.visitLdcInsn("Tome"); + mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true); + mv.visitInsn(POP); + Label l2 = new Label(); + mv.visitLabel(l2); + mv.visitVarInsn(ALOAD, 1); + mv.visitLdcInsn("Jack"); + mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true); + mv.visitInsn(POP); + Label l3 = new Label(); + mv.visitLabel(l3); + mv.visitVarInsn(ALOAD, 1); + mv.visitLdcInsn("Lily"); + mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true); + mv.visitInsn(POP); + Label l4 = new Label(); + mv.visitLabel(l4); + mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); + mv.visitTypeInsn(NEW, "java/lang/StringBuilder"); + mv.visitInsn(DUP); + mv.visitLdcInsn(">>>>>>>>>>testList > list.size = "); + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "", "(Ljava/lang/String;)V", false); + mv.visitVarInsn(ALOAD, 1); + mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "size", "()I", true); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(I)Ljava/lang/StringBuilder;", + false); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false); + Label l5 = new Label(); + mv.visitLabel(l5); + mv.visitVarInsn(ALOAD, 1); + mv.visitInsn(ARETURN); + Label l6 = new Label(); + mv.visitLabel(l6); + mv.visitMaxs(4, 2); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC + ACC_VARARGS, "testMapList", "(Z[Ljava/util/Map;)Ljava/util/List;", + "(Z[Ljava/util/Map;)Ljava/util/List;>;", + null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitTypeInsn(NEW, "java/util/ArrayList"); + mv.visitInsn(DUP); + mv.visitMethodInsn(INVOKESPECIAL, "java/util/ArrayList", "", "()V", false); + mv.visitVarInsn(ASTORE, 3); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitVarInsn(ILOAD, 1); + Label l2 = new Label(); + mv.visitJumpInsn(IFEQ, l2); + Label l3 = new Label(); + mv.visitLabel(l3); + mv.visitVarInsn(ALOAD, 2); + mv.visitInsn(DUP); + mv.visitVarInsn(ASTORE, 7); + mv.visitInsn(ARRAYLENGTH); + mv.visitVarInsn(ISTORE, 6); + mv.visitInsn(ICONST_0); + mv.visitVarInsn(ISTORE, 5); + Label l4 = new Label(); + mv.visitJumpInsn(GOTO, l4); + Label l5 = new Label(); + mv.visitLabel(l5); + mv.visitFrame(Opcodes.F_FULL, 8, + new Object[] {"com/hks/asm/Hello", Opcodes.INTEGER, "[Ljava/util/Map;", + "java/util/List", Opcodes.TOP, Opcodes.INTEGER, Opcodes.INTEGER, "[Ljava/util/Map;" }, + 0, new Object[] {}); + mv.visitVarInsn(ALOAD, 7); + mv.visitVarInsn(ILOAD, 5); + mv.visitInsn(AALOAD); + mv.visitVarInsn(ASTORE, 4); + Label l6 = new Label(); + mv.visitLabel(l6); + mv.visitVarInsn(ALOAD, 3); + mv.visitVarInsn(ALOAD, 4); + mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true); + mv.visitInsn(POP); + Label l7 = new Label(); + mv.visitLabel(l7); + mv.visitIincInsn(5, 1); + mv.visitLabel(l4); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitVarInsn(ILOAD, 5); + mv.visitVarInsn(ILOAD, 6); + mv.visitJumpInsn(IF_ICMPLT, l5); + mv.visitLabel(l2); + mv.visitFrame(Opcodes.F_FULL, 4, new Object[] {"com/hks/asm/Hello", Opcodes.INTEGER, + "[Ljava/util/Map;", "java/util/List" }, 0, new Object[] {}); + mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); + mv.visitTypeInsn(NEW, "java/lang/StringBuilder"); + mv.visitInsn(DUP); + mv.visitLdcInsn(">>>>>>>>>>testMapList > list.size = "); + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "", "(Ljava/lang/String;)V", false); + mv.visitVarInsn(ALOAD, 3); + mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "size", "()I", true); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(I)Ljava/lang/StringBuilder;", + false); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false); + Label l8 = new Label(); + mv.visitLabel(l8); + mv.visitVarInsn(ALOAD, 3); + mv.visitInsn(ARETURN); + Label l9 = new Label(); + mv.visitLabel(l9); + mv.visitMaxs(4, 8); + mv.visitEnd(); + } + cw.visitEnd(); + + return cw.toByteArray(); + } + + /** + * 生成保存class文件 + * + */ + @Test + public void mainTest() { + try { + byte[] data = generatorHelloClass(); + File file = new File("/Users/yiche/github/eight-sorting-algorithms/src/test/java/com/hks/eightsortingalgorithms/asm/hello/Hello.class"); + FileOutputStream fos = new FileOutputStream(file); + fos.write(data); + fos.close(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + /** + * AOP测试 + * + * @param args + */ + public static void main(String[] args) { + try { + byte[] data = generatorHelloClass(); + + ClassWriter cw = new ClassWriter(0); + ClassReader cr = new ClassReader(data); + cr.accept(new AopClassAdapter(ASM5, cw), ClassReader.SKIP_DEBUG); + + data = cw.toByteArray(); + + MyClassLoader myClassLoader = new MyClassLoader(); + Class helloClass = myClassLoader.defineClass(null, data); + Object obj = helloClass.newInstance(); + Method method = helloClass.getMethod("display", null); + method.invoke(obj, null); + + method = helloClass.getMethod("testList", null); + Object result = method.invoke(obj, null); + System.out.println(result); + } catch (Exception e) { + e.printStackTrace(); + } + } + +} diff --git a/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/MyClassLoader.java b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/MyClassLoader.java new file mode 100644 index 0000000..6b42314 --- /dev/null +++ b/java-aspect/delombok/src-bak/src/main/java/com/hks/asm/MyClassLoader.java @@ -0,0 +1,31 @@ +package com.hks.asm; + +import org.objectweb.asm.Opcodes; +/** + * @Author: hekuangsheng + * @Date: 2018/10/19 + * + * 自定义ClassLoader + */ +public class MyClassLoader extends ClassLoader implements Opcodes { + + + public MyClassLoader() { + super(); + } + + public MyClassLoader(ClassLoader parent) { + super(parent); + } + + @Override + public Class loadClass(String name) throws ClassNotFoundException { + return super.loadClass(name); + } + + public Class defineClass(String name, byte[] b){ + return super.defineClass(name, b, 0, b.length); + } + +} + diff --git a/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/BTraceOnMethodDemo.java b/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/BTraceOnMethodDemo.java new file mode 100644 index 0000000..7071175 --- /dev/null +++ b/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/BTraceOnMethodDemo.java @@ -0,0 +1,23 @@ +package com.hks.btrace; + +import java.util.concurrent.TimeUnit; + +public class BTraceOnMethodDemo { + public static void main(String[] args) { + try { + TimeUnit.SECONDS.sleep(15); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("start main method..."); + new Thread(() -> { + while (true) { + try { + TimeUnit.SECONDS.sleep(1); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + }).start(); + } +} diff --git a/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/BTraceOnMethodDemoTracer.java b/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/BTraceOnMethodDemoTracer.java new file mode 100644 index 0000000..523bada --- /dev/null +++ b/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/BTraceOnMethodDemoTracer.java @@ -0,0 +1,16 @@ +package com.hks.btrace; + +import com.sun.btrace.annotations.BTrace; +import com.sun.btrace.annotations.OnMethod; + +import static com.sun.btrace.BTraceUtils.println; + +@BTrace +public class BTraceOnMethodDemoTracer { + + @OnMethod(clazz = "java.lang.Thread", method = "start") + public static void onThreadStart() { + println("tracing method start"); + } + +} diff --git a/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/ExpandCapacity.java b/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/ExpandCapacity.java new file mode 100644 index 0000000..e613a3e --- /dev/null +++ b/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/ExpandCapacity.java @@ -0,0 +1,39 @@ +package com.hks.btrace; + +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +public class ExpandCapacity { + public static final int ONE_MB = 1024 * 1024; + public static void main(String[] args) throws Exception { + mapExpandCapacity(); + } + /** + * java.util.HashMap#resize(int) + * 何时扩容，发生扩容时候的上下文情况 + */ + public static void mapExpandCapacity() throws Exception { + new Thread(new Runnable() { + @Override + public void run() { + while (true) { + //这是模拟主要逻辑 + //16,0.75 16*0.75=12 + Map map = new HashMap(); + int size = 100; + for (int i = 0; i < size; i++) { + map.put(i, new Byte[ONE_MB]); + } + System.out.println("Expand SIZE = " + map.size()); + try { + TimeUnit.SECONDS.sleep(10); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + }, "mapExpandCapacity").start(); + TimeUnit.HOURS.sleep(1); + } +} diff --git a/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/ExpandCapacityBtrace.java b/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/ExpandCapacityBtrace.java new file mode 100644 index 0000000..a807bf0 --- /dev/null +++ b/java-btrace/delombok/src-bak/src/main/java/com/hks/btrace/ExpandCapacityBtrace.java @@ -0,0 +1,31 @@ +package com.hks.btrace; + +import com.sun.btrace.BTraceUtils; +import com.sun.btrace.annotations.*; + +import java.util.Map; + +import static com.sun.btrace.BTraceUtils.*; +import static com.sun.btrace.BTraceUtils.Reflective.classForName; + +@BTrace +public class ExpandCapacityBtrace { + @OnMethod(clazz = "java.util.HashMap", method = "resize", + location = @Location(value = Kind.CALL, clazz = "/.*/", method = "/.*/")) + public static void traceMapExpandCapacity(@ProbeClassName String probeClass, @ProbeMethodName String probeMethod, + @Self Object self, int newCapacity) { + //java/util/HashMap.resize + String point = Strings.strcat(Strings.strcat(probeClass, "."), probeMethod); + Class clazz = classForName("java.util.HashMap"); + println(Strings.strcat(point, "======")); + //获取实例protected变量 + Map.Entry[] table= (Map.Entry[]) get(field(clazz, "table", true), self); + int threshold = getInt(field(clazz, "threshold", true), self); + int size = getInt(field(clazz, "size", true), self); + println(Strings.strcat("newCapacity:", str(newCapacity))); + println(Strings.strcat("table.length:", str(table.length))); + println(Strings.strcat("size:", str(size))); + println(Strings.strcat("threshold:", str(threshold))); + println(Strings.strcat(point, "------------")); + } +} diff --git a/java-cache/delombok/src-bak/src/main/java/com/hks/cache/LRUAbstractMap.java b/java-cache/delombok/src-bak/src/main/java/com/hks/cache/LRUAbstractMap.java new file mode 100644 index 0000000..7e9aa2d --- /dev/null +++ b/java-cache/delombok/src-bak/src/main/java/com/hks/cache/LRUAbstractMap.java @@ -0,0 +1,264 @@ +/* + * 文件名：LRUAbstractMap.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/7 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.cache; + +import com.google.common.util.concurrent.ThreadFactoryBuilder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Set; +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicInteger; + +public class LRUAbstractMap extends java.util.AbstractMap { + private final static Logger LOGGER = LoggerFactory.getLogger(LRUAbstractMap.class); + /** + * 检查是否超期线程 + */ + private ExecutorService checkTimePool ; + /** + * map 最大size + */ + private final static int MAX_SIZE = 1024 ; + private final static ArrayBlockingQueue QUEUE = new ArrayBlockingQueue<>(MAX_SIZE) ; + /** + * 默认大小 + */ + private final static int DEFAULT_ARRAY_SIZE =1024 ; + /** + * 数组长度 + */ + private int arraySize ; + /** + * 数组 + */ + private Object[] arrays ; + /** + * 判断是否停止 flag + */ + private volatile boolean flag = true ; + /** + * 超时时间 + */ + private final static Long EXPIRE_TIME = 60 * 60 * 1000L ; + /** + * 整个 Map 的大小 + */ + private volatile AtomicInteger size ; + public LRUAbstractMap() { + arraySize = DEFAULT_ARRAY_SIZE; + arrays = new Object[arraySize] ; + //开启一个线程检查最先放入队列的值是否超期 + executeCheckTime(); + } + /** + * 开启一个线程检查最先放入队列的值是否超期 设置为守护线程 + */ + private void executeCheckTime() { + ThreadFactory namedThreadFactory = new ThreadFactoryBuilder() + .setNameFormat("check-thread-%d") + .setDaemon(true) + .build(); + checkTimePool = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, + new ArrayBlockingQueue<>(1),namedThreadFactory,new ThreadPoolExecutor.AbortPolicy()); + checkTimePool.execute(new CheckTimeThread()) ; + } + @Override + public Set entrySet() { + return super.keySet(); + } + @Override + public Object put(Object key, Object value) { + int hash = hash(key); + int index = hash % arraySize ; + Node currentNode = (Node) arrays[index] ; + if (currentNode == null){ + arrays[index] = new Node(null,null, key, value); + //写入队列 + QUEUE.offer((Node) arrays[index]) ; + sizeUp(); + }else { + Node cNode = currentNode ; + Node nNode = cNode ; + //存在就覆盖 + if (nNode.key == key){ + cNode.val = value ; + } + while (nNode.next != null){ + //key 存在 就覆盖 简单判断 + if (nNode.key == key){ + nNode.val = value ; + break ; + }else { + //不存在就新增链表 + sizeUp(); + Node node = new Node(nNode,null,key,value) ; + //写入队列 + QUEUE.offer(currentNode) ; + cNode.next = node ; + } + nNode = nNode.next ; + } + } + return null ; + } + @Override + public Object get(Object key) { + int hash = hash(key) ; + int index = hash % arraySize ; + Node currentNode = (Node) arrays[index] ; + if (currentNode == null){ + return null ; + } + if (currentNode.next == null){ + //更新时间 + currentNode.setUpdateTime(System.currentTimeMillis()); + //没有冲突 + return currentNode ; + } + Node nNode = currentNode ; + while (nNode.next != null){ + if (nNode.key == key){ + //更新时间 + currentNode.setUpdateTime(System.currentTimeMillis()); + return nNode ; + } + nNode = nNode.next ; + } + return super.get(key); + } + @Override + public Object remove(Object key) { + int hash = hash(key) ; + int index = hash % arraySize ; + Node currentNode = (Node) arrays[index] ; + if (currentNode == null){ + return null ; + } + if (currentNode.key == key){ + sizeDown(); + arrays[index] = null ; + //移除队列 + QUEUE.poll(); + return currentNode ; + } + Node nNode = currentNode ; + while (nNode.next != null){ + if (nNode.key == key){ + sizeDown(); + //在链表中找到了 把上一个节点的 next 指向当前节点的下一个节点 + nNode.pre.next = nNode.next ; + nNode = null ; + //移除队列 + QUEUE.poll(); + return nNode; + } + nNode = nNode.next ; + } + return super.remove(key); + } + /** + * 增加size + */ + private void sizeUp(){ + //在put值时候认为里边已经有数据了 + flag = true ; + if (size == null){ + size = new AtomicInteger() ; + } + int size = this.size.incrementAndGet(); + if (size >= MAX_SIZE) { + //找到队列头的数据 + Node node = QUEUE.poll() ; + if (node == null){ + throw new RuntimeException("data error") ; + } + //移除该 key + Object key = node.key ; + remove(key) ; + lruCallback() ; + } + } + /** + * 数量减小 + */ + private void sizeDown(){ + if (QUEUE.size() == 0){ + flag = false ; + } + this.size.decrementAndGet() ; + } + @Override + public int size() { + return size.get() ; + } + /** + * 链表 + */ + private class Node{ + private Node next ; + private Node pre ; + private Object key ; + private Object val ; + private Long updateTime ; + public Node(Node pre,Node next, Object key, Object val) { + this.pre = pre ; + this.next = next; + this.key = key; + this.val = val; + this.updateTime = System.currentTimeMillis() ; + } + public void setUpdateTime(Long updateTime) { + this.updateTime = updateTime; + } + public Long getUpdateTime() { + return updateTime; + } + @Override + public String toString() { + return "Node{" + + "key=" + key + + ", val=" + val + + '}'; + } + } + /** + * copy HashMap 的 hash 实现 + * @param key + * @return + */ + public int hash(Object key) { + int h; + return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); + } + private void lruCallback(){ + LOGGER.debug("lruCallback"); + } + private class CheckTimeThread implements Runnable{ + @Override + public void run() { + while (flag){ + try { + Node node = QUEUE.poll(); + if (node == null){ + continue ; + } + Long updateTime = node.getUpdateTime() ; + if ((updateTime - System.currentTimeMillis()) >= EXPIRE_TIME){ + remove(node.key) ; + } + } catch (Exception e) { + LOGGER.error("InterruptedException"); + } + } + } + } +} diff --git a/java-cache/delombok/src-bak/src/main/java/com/hks/cache/LRULinkedMap.java b/java-cache/delombok/src-bak/src/main/java/com/hks/cache/LRULinkedMap.java new file mode 100644 index 0000000..8fea469 --- /dev/null +++ b/java-cache/delombok/src-bak/src/main/java/com/hks/cache/LRULinkedMap.java @@ -0,0 +1,46 @@ +/* + * 文件名：LRULinkedMap.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/7 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.cache; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.Map; + +public class LRULinkedMap { + /** + * 最大缓存大小 + */ + private int cacheSize; + private LinkedHashMap cacheMap ; + public LRULinkedMap(int cacheSize) { + this.cacheSize = cacheSize; + cacheMap = new LinkedHashMap(16,0.75F,true){ + @Override + protected boolean removeEldestEntry(Map.Entry eldest) { + if (cacheSize + 1 == cacheMap.size()){ + return true ; + }else { + return false ; + } + } + }; + } + public void put(K key,V value){ + cacheMap.put(key,value) ; + } + public V get(K key){ + return cacheMap.get(key) ; + } + public Collection> getAll() { + return new ArrayList>(cacheMap.entrySet()); + } +} \ No newline at end of file diff --git a/java-cache/delombok/src-bak/src/main/java/com/hks/cache/LRUMap.java b/java-cache/delombok/src-bak/src/main/java/com/hks/cache/LRUMap.java new file mode 100644 index 0000000..bcbdc2f --- /dev/null +++ b/java-cache/delombok/src-bak/src/main/java/com/hks/cache/LRUMap.java @@ -0,0 +1,171 @@ +/* + * 文件名：LRUMap.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/7 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.cache; + +import java.util.HashMap; +import java.util.Map; + +public class LRUMap { + private final Map cacheMap = new HashMap<>(); + /** + * 最大缓存大小 + */ + private int cacheSize; + /** + * 节点大小 + */ + private int nodeCount; + /** + * 头结点 + */ + private Node header; + /** + * 尾结点 + */ + private Node tailer; + public LRUMap(int cacheSize) { + this.cacheSize = cacheSize; + //头结点的下一个结点为空 + header = new Node<>(); + header.next = null; + //尾结点的上一个结点为空 + tailer = new Node<>(); + tailer.tail = null; + //双向链表 头结点的上结点指向尾结点 + header.tail = tailer; + //尾结点的下结点指向头结点 + tailer.next = header; + } + public void put(K key, V value) { + cacheMap.put(key, value); + //双向链表中添加结点 + addNode(key, value); + } + public V get(K key){ + Node node = getNode(key); + //移动到头结点 + moveToHead(node) ; + return cacheMap.get(key); + } + private void moveToHead(Node node){ + //如果是最后的一个节点 + if (node.tail == null){ + node.next.tail = null ; + tailer = node.next ; + nodeCount -- ; + } + //如果是本来就是头节点 不作处理 + if (node.next == null){ + return ; + } + //如果处于中间节点 + if (node.tail != null && node.next != null){ + //它的上一节点指向它的下一节点 也就删除当前节点 + node.tail.next = node.next ; + nodeCount -- ; + } + //最后在头部增加当前节点 + //注意这里需要重新 new 一个对象，不然原本的node 还有着下面的引用，会造成内存溢出。 + node = new Node<>(node.getKey(),node.getValue()) ; + addHead(node) ; + } + /** + * 链表查询 效率较低 + * @param key + * @return + */ + private Node getNode(K key){ + Node node = tailer ; + while (node != null){ + if (node.getKey().equals(key)){ + return node ; + } + node = node.next ; + } + return null ; + } + /** + * 写入头结点 + * @param key + * @param value + */ + private void addNode(K key, V value) { + Node node = new Node<>(key, value); + //容量满了删除最后一个 + if (cacheSize == nodeCount) { + //删除尾结点 + delTail(); + } + //写入头结点 + addHead(node); + } + /** + * 添加头结点 + * + * @param node + */ + private void addHead(Node node) { + //写入头结点 + header.next = node; + node.tail = header; + header = node; + nodeCount++; + //如果写入的数据大于2个 就将初始化的头尾结点删除 + if (nodeCount == 2) { + tailer.next.next.tail = null; + tailer = tailer.next.next; + } + } + private void delTail() { + //把尾结点从缓存中删除 + cacheMap.remove(tailer.getKey()); + //删除尾结点 + tailer.next.tail = null; + tailer = tailer.next; + nodeCount--; + } + private class Node { + private K key; + private V value; + Node tail; + Node next; + public Node(K key, V value) { + this.key = key; + this.value = value; + } + public Node() { + } + public K getKey() { + return key; + } + public void setKey(K key) { + this.key = key; + } + public V getValue() { + return value; + } + public void setValue(V value) { + this.value = value; + } + } + @Override + public String toString() { + StringBuilder sb = new StringBuilder() ; + Node node = tailer ; + while (node != null){ + sb.append(node.getKey()).append(":") + .append(node.getValue()) + .append("-->") ; + node = node.next ; + } + return sb.toString(); + } +} diff --git a/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/ClassLoaderLeakExample.java b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/ClassLoaderLeakExample.java new file mode 100644 index 0000000..545c679 --- /dev/null +++ b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/ClassLoaderLeakExample.java @@ -0,0 +1,10 @@ +package com.hks.classLoader; + +/** + * @author heks + * @description: TODO + * @date 2020/11/16 + */ +public final class ClassLoaderLeakExample { + +} diff --git a/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/ClassLoaderTest.java b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/ClassLoaderTest.java new file mode 100644 index 0000000..ed793e2 --- /dev/null +++ b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/ClassLoaderTest.java @@ -0,0 +1,33 @@ +package com.hks.classLoader; + +import java.io.IOException; +import java.io.InputStream; + +public class ClassLoaderTest { + + public static void main(String[] args) throws Exception{ + ClassLoader myLoader = new ClassLoader() { + @Override + public Class loadClass(String name) throws ClassNotFoundException { + try { + String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class"; + InputStream is = getClass().getResourceAsStream(fileName); + if (is == null) { + return super.loadClass(name); + } + byte[] b = new byte[is.available()]; + is.read(b); + return defineClass(name, b, 0, b.length); + } catch (IOException e) { + throw new ClassNotFoundException(name); + } + } + }; + + Object obj = myLoader.loadClass("com.hks.classLoader.ClassLoaderTest").newInstance(); + + System.out.println(obj.getClass()); + System.out.println(obj instanceof ClassLoaderTest); + } + +} diff --git a/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/MyClassLoader.java b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/MyClassLoader.java new file mode 100644 index 0000000..bcba27f --- /dev/null +++ b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/MyClassLoader.java @@ -0,0 +1,40 @@ +package com.hks.classLoader; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; + +/** + * 第一步，首先定义自己的类装载器，从ClassLoader继承，重写它的findClass方法， + * 至于为什么要这么做，大家如果看过笔记三就知道，双亲委托模式下， + * 如果parent没办法loadClass，bootStrap也没把办法loadClass的时候，jvm是会调用ClassLoader对象或者它子类对象的findClass来装载。 + */ +public class MyClassLoader extends ClassLoader{ + + @Override + protected Class findClass(String name) throws ClassNotFoundException { + byte[] data = getByteArray(name); + if (data == null) { + throw new ClassNotFoundException(); + } + return defineClass(name, data, 0, data.length); + } + + private byte[] getByteArray(String name){ + String filePath = name.replace(".", File.separator); + byte[] buf = null; + try { + FileInputStream in = new FileInputStream(filePath); + buf = new byte[in.available()]; + in.read(buf); + } catch (FileNotFoundException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + return buf; + } + + +} diff --git a/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/TestBeLoader.java b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/TestBeLoader.java new file mode 100644 index 0000000..2dc3ffd --- /dev/null +++ b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/TestBeLoader.java @@ -0,0 +1,15 @@ +package com.hks.classLoader; + +/** + * 第二步，定义一个类，专门用于被装载，这里我们定义了一个静态代码块，待会用到它 + */ +public class TestBeLoader { + + static{ + System.out.println("TestBeLoader init"); + } + public void sayHello(){ + System.out.println("hello"); + } + +} diff --git a/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/TestClassLoaderDemo.java b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/TestClassLoaderDemo.java new file mode 100644 index 0000000..6a34f58 --- /dev/null +++ b/java-classloader/delombok/src-bak/src/main/java/com/hks/classLoader/TestClassLoaderDemo.java @@ -0,0 +1,27 @@ +package com.hks.classLoader; + +/** + * 第三步，定义一个有main函数入口的public类来做验证 + */ +public class TestClassLoaderDemo { + + public static void main(String[] args) throws InstantiationException, IllegalAccessException { + Class thisCls = TestClassLoaderDemo.class; + MyClassLoader myClassLoader = new MyClassLoader(); + System.out.println(thisCls.getClassLoader()); + System.out.println(myClassLoader.getParent()); + try { + //用自定义的类装载器来装载类,这是动态扩展的一种途径 + Class cls2 = myClassLoader.loadClass("com.hks.eightsortingalgorithms.classLoader.TestBeLoader"); + System.out.println(cls2.getClassLoader()); + TestBeLoader test=(TestBeLoader)cls2.newInstance(); + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + } + + /** + * 第四步，查看运行结果 + */ + +} diff --git a/java-classloader/delombok/src-bak/src/test/java/IntegerTest.java b/java-classloader/delombok/src-bak/src/test/java/IntegerTest.java new file mode 100644 index 0000000..4fe9148 --- /dev/null +++ b/java-classloader/delombok/src-bak/src/test/java/IntegerTest.java @@ -0,0 +1,20 @@ +public class IntegerTest { + + public static void main(String[] args) { + Integer a = 1; + Integer b = 2; + Integer c = 3; + Integer d = 3; + Integer e = 321; + Integer f = 321; + Long g = 3L; + + System.out.println(c == d); + System.out.println(e == f); + System.out.println(c == (a + b)); + System.out.println(c.equals(a + b)); + System.out.println(g == (a + b)); + System.out.println(g.equals(a + b)); + } + +} diff --git a/java-classloader/src/main/java/com/hks/classLoader/ClassLoaderLeakExample.java b/java-classloader/src/main/java/com/hks/classLoader/ClassLoaderLeakExample.java new file mode 100644 index 0000000..545c679 --- /dev/null +++ b/java-classloader/src/main/java/com/hks/classLoader/ClassLoaderLeakExample.java @@ -0,0 +1,10 @@ +package com.hks.classLoader; + +/** + * @author heks + * @description: TODO + * @date 2020/11/16 + */ +public final class ClassLoaderLeakExample { + +} diff --git a/java-classloader/src/test/java/IntegerTest.java b/java-classloader/src/test/java/IntegerTest.java new file mode 100644 index 0000000..4fe9148 --- /dev/null +++ b/java-classloader/src/test/java/IntegerTest.java @@ -0,0 +1,20 @@ +public class IntegerTest { + + public static void main(String[] args) { + Integer a = 1; + Integer b = 2; + Integer c = 3; + Integer d = 3; + Integer e = 321; + Integer f = 321; + Long g = 3L; + + System.out.println(c == d); + System.out.println(e == f); + System.out.println(c == (a + b)); + System.out.println(c.equals(a + b)); + System.out.println(g == (a + b)); + System.out.println(g.equals(a + b)); + } + +} diff --git a/java-collectors/delombok/src-bak/src/main/java/com/hks/compare/MapCompare.java b/java-collectors/delombok/src-bak/src/main/java/com/hks/compare/MapCompare.java new file mode 100644 index 0000000..dd02abe --- /dev/null +++ b/java-collectors/delombok/src-bak/src/main/java/com/hks/compare/MapCompare.java @@ -0,0 +1,170 @@ +package com.hks.compare; + +import org.junit.Test; + +import java.io.IOException; +import java.util.*; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/24 + */ +public class MapCompare { + + /** + * 按Key进行排序 + * + * TreeMap既可满足此类需求，向其构造方法 TreeMap(Comparator comparator) + * 传入我们自定义的比较器即可实现按键排序。 + */ + @Test + public void TestSort1(){ + Map resultMap = new TreeMap<>(new Comparator() { + @Override + public int compare(String str1, String str2) { + return str1.compareTo(str2); + } + }); + resultMap.put("1", "kfc"); + resultMap.put("4", "cba"); + resultMap.put("2", "wnba"); + resultMap.put("3", "nba"); + for (Map.Entry entry : resultMap.entrySet()) { + System.out.println(entry.getKey() + " " + entry.getValue()); + } + } + + /** + * 按Value进行排序 + * + * 将待排序Map中的所有元素置于一个列表中，接着使用Collections的一个静态方法 sort(List list, Comparator c)  + * 来排序列表，同样是用比较器定义比较规则。 + * 排序后的列表中的元素再依次装入Map，为了肯定的保证Map中元素与排序后的List中的元素的顺序一致，使用了LinkedHashMap数据类型。 + */ + @Test + public void TestSort2(){ + Map resultMap = new TreeMap(); + resultMap.put("kfc", "1"); + resultMap.put("wnba", "2"); + resultMap.put("nba", "6"); + resultMap.put("cba", "4"); + resultMap.put("eba", "5"); + resultMap.put("ebe", "0"); + Map sortedMap = new LinkedHashMap(); + List> entryList = new ArrayList>( + resultMap.entrySet()); + + Collections.sort(entryList, new Comparator>() { + @Override + public int compare(Map.Entry o1, Map.Entry o2) { + return o1.getValue().compareTo(o2.getValue()); + } + }); + + Iterator> iter = entryList.iterator(); + Map.Entry tmpEntry = null; + while (iter.hasNext()) { + tmpEntry = iter.next(); + sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue()); + } + + for (Map.Entry entry : sortedMap.entrySet()) { + System.out.println(entry.getKey() + " " + entry.getValue()); + } + } + + /** + * 三种排序 + * 1.升序排列 + * 2.降序排序 + * 3.随机排序 + */ + @Test + public void TestSort3() { + //默认的TreeMap升序排列 + TreeMap map1 = new TreeMap(); + + //降序排序 + TreeMap map2 = new TreeMap(new Comparator() { + /* + * int compare(Object o1, Object o2) 返回一个基本类型的整型， + * 返回负数表示：o1 小于o2， + * 返回0 表示：o1和o2相等， + * 返回正数表示：o1大于o2。 + */ + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + //随机排序 + TreeMap map3 = new TreeMap(new Comparator() { + /* + * int compare(Object o1, Object o2) 返回一个基本类型的整型， + * 返回负数表示：o1 小于o2， + * 返回0 表示：o1和o2相等， + * 返回正数表示：o1大于o2。 + */ + public int compare(Integer a, Integer b) { + int randomOne = (int) (Math.random() * 10); + int randomTwo = (int) (Math.random() * 10); + return randomOne - randomTwo; + } + }); + + map2.put(1, 2); + map2.put(2, 4); + map2.put(2, 4); + map2.put(7, 1); + map2.put(5, 2); + System.out.println("Map2降序排列=" + map2); + + map1.put(1, 2); + map1.put(2, 4); + map1.put(7, 1); + map1.put(5, 2); + map1.put(5, 2); + System.out.println("map1升序排序=" + map1); + + map3.put(1, 2); + map3.put(2, 4); + map3.put(7, 1); + map3.put(5, 2); + map3.put(9, 2); + map3.put(11, 2); + map3.put(11, 2); + System.out.println("map3随机排序=" + map3); + } + + /** + * Map转List 随机排序 + * @throws IOException + */ + @Test + public void TestSort4() throws IOException { + Map unsortMap = new HashMap<>(); + unsortMap.put("z", 10); + unsortMap.put("b", 5); + unsortMap.put("a", 6); + unsortMap.put("c", 20); + unsortMap.put("d", 1); + unsortMap.put("e", 7); + unsortMap.put("y", 8); + unsortMap.put("n", 99); + unsortMap.put("g", 50); + unsortMap.put("m", 2); + unsortMap.put("f", 9); + List list = new LinkedList(unsortMap.keySet()); + //随机排序 + Collections.shuffle(list); + Map result = new HashMap(); + for (int i = 0; i < list.size(); i++) { + String jsonString = list.get(i); + result.put(jsonString, unsortMap.get(jsonString)); + } + for (Map.Entry entry : result.entrySet()) { + System.out.println(entry.getKey() + " " + entry.getValue()); + } + } + +} diff --git a/java-collectors/delombok/src-bak/src/main/java/com/hks/conllectors/IteratorFor.java b/java-collectors/delombok/src-bak/src/main/java/com/hks/conllectors/IteratorFor.java new file mode 100644 index 0000000..30d5cfb --- /dev/null +++ b/java-collectors/delombok/src-bak/src/main/java/com/hks/conllectors/IteratorFor.java @@ -0,0 +1,41 @@ +package com.hks.conllectors; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +public class IteratorFor { + + public static void main(String[] args) { + /** + * 不要在 foreach 循环里进行元素的 remove / add 操作。 + * remove 元素请使用 Iterator方式, + * 如果并发操作,需要对 Iterator 对象加锁 + */ + List a = new ArrayList<>(); + a.add("1"); + a.add("2"); + try { + for (String temp : a) { + if ("2".equals(temp)) { + a.remove(temp); + } + } + } catch (Exception ex) { + System.out.print(ex.getMessage() + "\n"); + } + + /** + * 正例稳定正确地运行 + */ + Iterator it = a.iterator(); + while (it.hasNext()) { + String temp = it.next().toString(); + System.out.print(temp + "\n"); + if ("2".equals(temp)) { + it.remove(); + } + } + } + +} diff --git a/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/Animal.java b/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/Animal.java new file mode 100644 index 0000000..419b473 --- /dev/null +++ b/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/Animal.java @@ -0,0 +1,27 @@ +package com.hks.genericity; + +public class Animal { + + private String type; + private String describe; + public Animal(){ + + } + public Animal(String type,String describe){ + this.type = type; + this.describe = describe; + } + public String getType() { + return type; + } + public void setType(String type) { + this.type = type; + } + public String getDescribe() { + return describe; + } + public void setDescribe(String describe) { + this.describe = describe; + } + +} diff --git a/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/Content.java b/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/Content.java new file mode 100644 index 0000000..4482f30 --- /dev/null +++ b/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/Content.java @@ -0,0 +1,65 @@ +package com.hks.genericity; + +import java.util.ArrayList; +import java.util.List; + +/** + * 是上界通配符。逻辑上来说，一个可以往里面放动物的容器，也可以往里面放狗，因为狗是继承了动物的， + * 所以从逻辑上来说，一个可以放狗的容器也应该是继承一个可以放动物的容器的。 + * + * 但是Java中这是不对的。这时候就需要上界通配符来解决这个问题。 + * @param + */ +public class Content { + + private String contentName; + private List content; + private T t; + private int size; + public Content(){ + content = new ArrayList(); + size = 0; + } + public String getContentName() { + return contentName; + } + public void setContentName(String contentName) { + this.contentName = contentName; + } + + public List getContent() { + return content; + } + @SuppressWarnings("unchecked") + public void setContent(List content) { + this.content = (List) content; + } + + public void add(T content){ + this.content.add(content); + } + + public void getInfo(){ + System.out.println(content.toString()); + } + public int getSize(){ + size = content.size(); + return size; + } + public T getT() { + return t; + } + public void setT(T t) { + this.t = t; + } + + public void remove(int pos){ + this.content.remove(pos); + } + + public T get(int i){ + if(i>content.size()) + return null; + return content.get(i); + } +} diff --git a/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/Dog.java b/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/Dog.java new file mode 100644 index 0000000..1aeea02 --- /dev/null +++ b/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/Dog.java @@ -0,0 +1,24 @@ +package com.hks.genericity; + +public class Dog extends Animal { + private String name; + private int age; + public Dog(String type,String describe,String name,int age){ + super(type,describe); + this.name = name; + this.age = age; + } + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + public int getAge() { + return age; + } + public void setAge(int age) { + this.age = age; + } + +} diff --git a/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/RelationTest.java b/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/RelationTest.java new file mode 100644 index 0000000..b1d51f4 --- /dev/null +++ b/java-collectors/delombok/src-bak/src/main/java/com/hks/genericity/RelationTest.java @@ -0,0 +1,30 @@ +package com.hks.genericity; + +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; + +public class RelationTest { + + @Test + public void relationTest(){ + Content animalContent = new Content<>(); + + ///上界通配符 + /*List dogs = new ArrayList<>(); + dogs.add(new Dog("dog","wangwang","wangcai",10)); + animalContent.setContent(dogs);*/ + + ///下界通配符 + List animals = new ArrayList<>(); + animals.add(new Dog("dog","wangwang","wangcai",10)); + animalContent.setContent(animals); + animalContent.add(new Dog("cat","miaomiao","mimi",5)); + + List animalList = animalContent.getContent(); + Dog dog = (Dog)animalList.get(1); + System.out.println(dog.getDescribe()); + } + +} diff --git a/java-collectors/delombok/src-bak/src/main/java/com/hks/hashmap/A.java b/java-collectors/delombok/src-bak/src/main/java/com/hks/hashmap/A.java new file mode 100644 index 0000000..c31d66b --- /dev/null +++ b/java-collectors/delombok/src-bak/src/main/java/com/hks/hashmap/A.java @@ -0,0 +1,30 @@ +package com.hks.hashmap; + +public class A { + + private String code; + private String name; + @Override + public int hashCode() { + // TODO Auto-generated method stub + return code.hashCode()+name.hashCode(); + } + public String getCode() { + return code; + } + public void setCode(String code) { + this.code = code; + } + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + @Override + public String toString() { + // TODO Auto-generated method stub + return code.toString()+name.toString(); + } + +} diff --git a/java-collectors/delombok/src-bak/src/main/java/com/hks/hashmap/HashMapKeyTest.java b/java-collectors/delombok/src-bak/src/main/java/com/hks/hashmap/HashMapKeyTest.java new file mode 100644 index 0000000..ab343d2 --- /dev/null +++ b/java-collectors/delombok/src-bak/src/main/java/com/hks/hashmap/HashMapKeyTest.java @@ -0,0 +1,20 @@ +package com.hks.hashmap; + +import java.util.HashMap; +import java.util.Map; + +public class HashMapKeyTest { + + public static void main(String[] args) { + Map map = new HashMap(); + A a1 = new A(); + a1.setCode("123"); + a1.setName("456"); + map.put(a1, "test1"); + System.out.println(map); + a1.setCode("789"); + map.put(a1, "test2"); + System.out.println(map); + } + +} diff --git a/java-collectors/delombok/src-bak/src/main/java/com/hks/hashmap/LinkedHashMapTest.java b/java-collectors/delombok/src-bak/src/main/java/com/hks/hashmap/LinkedHashMapTest.java new file mode 100644 index 0000000..33a26a5 --- /dev/null +++ b/java-collectors/delombok/src-bak/src/main/java/com/hks/hashmap/LinkedHashMapTest.java @@ -0,0 +1,36 @@ +package com.hks.hashmap; + +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * LinkedHashMap除了支持默认的插入顺序，还支持访问顺序。 + * 所谓访问顺序(access-order)是指在迭代遍历列表中的元素时最近访问的元素会排在LinkedHashMap的尾部 + * + * 根据测试看输出 + */ +public class LinkedHashMapTest { + + public static void main(String[] args) { + Map map = new LinkedHashMap(16, 0.75F, true); + + for (int i = 1; i <= 5; i++) { + map.put(i + "", i); + } + Iterator> iterator = map.entrySet().iterator(); + while (iterator.hasNext()) { + System.out.println(iterator.next().getValue()); + } + + map.get("2"); + map.get("3"); + System.out.println("===============split line=================="); + + Iterator> iterator2 = map.entrySet().iterator(); + while (iterator2.hasNext()) { + System.out.println(iterator2.next().getValue()); + } + } + +} diff --git a/java-factory/delombok/src-bak/src/main/java/com/hks/factory/Fish.java b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/Fish.java new file mode 100644 index 0000000..d11c5a7 --- /dev/null +++ b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/Fish.java @@ -0,0 +1,15 @@ +package com.hks.factory; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + + * 定义食物的子类:鱼 + */ +public class Fish implements Food{ + + @Override + public void introduce() { + System.out.println("i am a fish"); + } +} diff --git a/java-factory/delombok/src-bak/src/main/java/com/hks/factory/Food.java b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/Food.java new file mode 100644 index 0000000..11efc16 --- /dev/null +++ b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/Food.java @@ -0,0 +1,9 @@ +package com.hks.factory; + +public interface Food { + + /** + * 使得所有食物都有一个共有的introduce方法 + */ + public void introduce(); +} diff --git a/java-factory/delombok/src-bak/src/main/java/com/hks/factory/FoodFactory.java b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/FoodFactory.java new file mode 100644 index 0000000..217aa39 --- /dev/null +++ b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/FoodFactory.java @@ -0,0 +1,24 @@ +package com.hks.factory; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + + * 通过反射机制实现的工厂 + */ +public class FoodFactory { + + public static Food getFood(String type) { + Food food = null; + try { + food = (Food) Class.forName("com.hks.factory." + type).newInstance(); + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } catch (InstantiationException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + return food; + } +} diff --git a/java-factory/delombok/src-bak/src/main/java/com/hks/factory/FoodFactoryTest.java b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/FoodFactoryTest.java new file mode 100644 index 0000000..cd74c95 --- /dev/null +++ b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/FoodFactoryTest.java @@ -0,0 +1,17 @@ +package com.hks.factory; + +import org.junit.Test; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + */ +public class FoodFactoryTest { + + @Test + public void test(){ + Food food = FoodFactory.getFood("Fish"); + food.introduce(); + } + +} diff --git a/java-factory/delombok/src-bak/src/main/java/com/hks/factory/Fruit.java b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/Fruit.java new file mode 100644 index 0000000..7e2c0e7 --- /dev/null +++ b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/Fruit.java @@ -0,0 +1,14 @@ +package com.hks.factory; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + + * 食物的子类，水果 + */ +public class Fruit implements Food { + @Override + public void introduce() { + System.out.println("i am the fruit"); + } +} diff --git a/java-factory/delombok/src-bak/src/main/java/com/hks/factory/SingletonClass.java b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/SingletonClass.java new file mode 100644 index 0000000..1c41d94 --- /dev/null +++ b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/SingletonClass.java @@ -0,0 +1,53 @@ +package com.hks.factory; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + *

+ * 使用构造函数，调用其中的方法，则实例化一个类是必不可少的步奏， + *

+ * 而是使用静态工厂方法，则可以对对象进行重复利用，这个特点在单例模式中使用颇多 + * + * 都是线程安全的 + */ +public class SingletonClass { + + private SingletonClass() { + } + + private static SingletonClass singletonClass = null; + + // 加锁机制 + public static SingletonClass getSingletonClass() { + if (singletonClass == null) { + synchronized (SingletonClass.class) { + if (singletonClass == null) { + singletonClass = new SingletonClass(); + } + } + } + return singletonClass; + } + + // 终极版本：volatile + private static volatile SingletonClass instance; + public static SingletonClass getSingleInstance() { + if (instance == null) { + synchronized (SingletonClass.class) { + if (instance == null) { + instance = new SingletonClass(); + } + } + } + return instance; + } + + // Happens-Before + private static class SingleHolder{ + public static SingletonClass instance = new SingletonClass(); + } + + public static SingletonClass getInstance(){ + return SingleHolder.instance; + } +} diff --git a/java-factory/delombok/src-bak/src/main/java/com/hks/factory/StaticFactoryClass.java b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/StaticFactoryClass.java new file mode 100644 index 0000000..299e5db --- /dev/null +++ b/java-factory/delombok/src-bak/src/main/java/com/hks/factory/StaticFactoryClass.java @@ -0,0 +1,13 @@ +package com.hks.factory; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + */ +public class StaticFactoryClass { + + public static Boolean valueOf(Boolean b) { + return b ? Boolean.TRUE : Boolean.FALSE; + } + +} diff --git a/java-factory/pom.xml b/java-factory/pom.xml index fb0a837..0f9f02e 100644 --- a/java-factory/pom.xml +++ b/java-factory/pom.xml @@ -8,5 +8,20 @@ java-factory 1.0-SNAPSHOT + + + + junit + junit + 4.13.2 + test + + + org.junit.jupiter + junit-jupiter + RELEASE + compile + + \ No newline at end of file diff --git a/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/Client.java b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/Client.java new file mode 100644 index 0000000..f4dc22c --- /dev/null +++ b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/Client.java @@ -0,0 +1,11 @@ +package com.hks.intercept; + +import java.util.ArrayList; +import java.util.List; + +/** + * 主调用接口 + */ +public abstract class Client { + public abstract void start(String say); +} diff --git a/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/ClientImp.java b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/ClientImp.java new file mode 100644 index 0000000..b99b189 --- /dev/null +++ b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/ClientImp.java @@ -0,0 +1,11 @@ +package com.hks.intercept; + +/** + * 上述接口实现类 + */ +public class ClientImp extends Client { + @Override + public void start(String say) { + System.out.println(say); + } +} diff --git a/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/ForwardingClient.java b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/ForwardingClient.java new file mode 100644 index 0000000..de99ba4 --- /dev/null +++ b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/ForwardingClient.java @@ -0,0 +1,14 @@ +package com.hks.intercept; + +/** + * 用于包装Client到另一个Client + */ +public abstract class ForwardingClient extends Client{ + //要包装的对象 + protected abstract Client delegate(); + + @Override + public void start(String say) { + delegate().start(say); + } +} diff --git a/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/ForwardingClientImpl.java b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/ForwardingClientImpl.java new file mode 100644 index 0000000..75f0a6c --- /dev/null +++ b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/ForwardingClientImpl.java @@ -0,0 +1,19 @@ +package com.hks.intercept; + +/** + * 一个简单的包装实现类,必须要传入要包装的对象 + */ +public class ForwardingClientImpl extends ForwardingClient{ + + //被委托对象 + private final Client client; + + public ForwardingClientImpl(Client client) { + this.client = client; + } + + @Override + protected Client delegate() { + return client; + } +} diff --git a/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/InterceptTest.java b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/InterceptTest.java new file mode 100644 index 0000000..bafae9a --- /dev/null +++ b/java-intercept/delombok/src-bak/src/main/java/com/hks/intercept/InterceptTest.java @@ -0,0 +1,26 @@ +package com.hks.intercept; + +public class InterceptTest { + public static void main(String[] args) { + //主要想执行的方法 + Client client = new ClientImp(); + //构造第一个拦截器 + Client intercept1 = new ForwardingClientImpl(client){ + @Override + public void start(String say) { + System.out.println("拦截器1"); + super.start(say); + } + }; + //构造第二个拦截器 + Client intercept2 = new ForwardingClientImpl(intercept1){ + @Override + public void start(String say) { + System.out.println("拦截器2"); + super.start(say); + } + }; + //执行主方法 + intercept2.start("这是要执行的方法"); + } +} diff --git a/java-jUnitPerf/delombok/src-bak/src/main/java/com/hks/junit/DemoServiceTest.java b/java-jUnitPerf/delombok/src-bak/src/main/java/com/hks/junit/DemoServiceTest.java new file mode 100644 index 0000000..d327266 --- /dev/null +++ b/java-jUnitPerf/delombok/src-bak/src/main/java/com/hks/junit/DemoServiceTest.java @@ -0,0 +1,60 @@ +package com.hks.junit; + +import com.github.noconnor.junitperf.JUnitPerfRule; +import com.github.noconnor.junitperf.JUnitPerfTest; +import com.github.noconnor.junitperf.JUnitPerfTestRequirement; +import com.github.noconnor.junitperf.reporting.providers.HtmlReportGenerator; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.springframework.http.ResponseEntity; +import org.springframework.web.client.RestTemplate; + +/** + * @JUnitPerfTest +Item 定义说明 Default值或说明 + @Rule 申明为JUnit 的Rule类 + JUnitPerfRule JUnitPerf 测试规则类 + @JunitPerfTest 声明为性能测试方法 + threads 测试使用的线程数 + durationMs 测试持续时间 + warmUpMs 测试热身时间 热身时间的测试数据不会计算进最后的测试结果 + maxExecutionsPerSecond 方法执行的上限 RateLimiter，控制TPS上限 + + 使用@JUnitPerfTestRequirement 可以给性能测试设置期望值，这个annotation的属性有: + 属性 定义 + percentits 设置例如90%/95%/50% 响应时间的期望 + executionsPerSec 期望每秒执行测试(TPS) + allowedErrorPercentage 允许错误比例 + minLatency 期望最小延时，如果实际最小延时超过这个数，则失败 + maxLatency 期望最大延时，如果实际最大延时超过这个，则失败 + meanLatency 期望中位数延时 + */ +public class DemoServiceTest { + @Rule + public JUnitPerfRule perfTestRule = new JUnitPerfRule(new HtmlReportGenerator("perf/report.html")); + + RestTemplate restTemplate; + @Before + public void setupService(){ + this.restTemplate = new RestTemplate(); + } + + @Test + @JUnitPerfTest(threads = 1000,durationMs = 1200,warmUpMs = 100,maxExecutionsPerSecond = 110) + @JUnitPerfTestRequirement(percentiles = "90:7,95:7,98:7,99:8", executionsPerSec = 2000, allowedErrorPercentage = 0.10f) + public void getServiceId() { + ResponseEntity result = restTemplate.getForEntity("https://blog.csdn.net/singgel/article/details/89397041",String.class,""); + System.out.println(result); + Assert.assertNotNull(result); + } + + @Test + @JUnitPerfTest(threads = 150,durationMs = 1200,warmUpMs = 100,maxExecutionsPerSecond = 110) + public void getServiceId_withoutTestRequirement() { + ResponseEntity result = restTemplate.getForEntity("http://rc.yiche.com/rc/v1/test",String.class,""); + System.out.println(result); + Assert.assertNotNull(result); + } +} diff --git a/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/DynamicMBean.java b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/DynamicMBean.java new file mode 100644 index 0000000..7bc3623 --- /dev/null +++ b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/DynamicMBean.java @@ -0,0 +1,4 @@ +package com.heks.jmx; + +public class DynamicMBean { +} diff --git a/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/HelloWorld.java b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/HelloWorld.java new file mode 100644 index 0000000..108f3fa --- /dev/null +++ b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/HelloWorld.java @@ -0,0 +1,45 @@ +package com.heks.jmx; + +import javax.management.Notification; +import javax.management.NotificationBroadcasterSupport; + +public class HelloWorld extends NotificationBroadcasterSupport implements HelloWorldMBean { + public String hello; + + private long seq = 0L; + + public HelloWorld() { + this.hello = "Hello World! I am a Standard MBean"; + } + + public HelloWorld(String hello) { + this.hello = hello; + } + + @Override + public String getHello() { + return hello; + } + + @Override + public void setHello(String hello) { + this.hello = hello; + } + + @Override + public Object getInstance() { + return new Object(); + } + + /** + * 当执行message的时候，发送一个消息(事件) + * @param msg + * @return + */ + @Override + public String message(String msg) { + Notification notice = new Notification("type1", this, seq++, " the message metheod is invoked,the argument ms: " + msg); + sendNotification(notice); + return "the message:" + msg; + } +} diff --git a/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/HelloWorldDynamic.java b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/HelloWorldDynamic.java new file mode 100644 index 0000000..0743810 --- /dev/null +++ b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/HelloWorldDynamic.java @@ -0,0 +1,75 @@ +package com.heks.jmx; + +import javax.management.*; +import javax.management.DynamicMBean; +import java.lang.reflect.Method; + +public class HelloWorldDynamic implements DynamicMBean { + public String hello; + + public HelloWorldDynamic() { + this.hello = "Hello World! I am a Dynamic MBean"; + } + + public HelloWorldDynamic(String hello) { + this.hello = hello; + } + + public String getHello() { + return hello; + } + + public void setHello(String hello) { + this.hello = hello; + } + + public Object getInstance() { + return new Object(); + } + + @Override + public Object getAttribute(String attribute) throws AttributeNotFoundException, MBeanException, ReflectionException { + if ("getInstance".equals(attribute)) { + return getInstance(); + } + return null; + } + + @Override + public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException { + + } + + @Override + public AttributeList getAttributes(String[] attributes) { + return null; + } + + @Override + public AttributeList setAttributes(AttributeList attributes) { + return null; + } + + @Override + public Object invoke(String actionName, Object[] params, String[] signature) throws MBeanException, ReflectionException { + return null; + } + + MBeanInfo info = null; + + @Override + public MBeanInfo getMBeanInfo() { + try { + Class cls = this.getClass(); + Method readMethod = cls.getMethod("getHello", new Class[0]); + MBeanAttributeInfo attributeInfo = new MBeanAttributeInfo("gh", "the first attribute", readMethod, null); + MBeanOperationInfo operationInfo = new MBeanOperationInfo("the first operation", cls.getMethod("getInstance",null)); + info = new MBeanInfo(cls.getName(),"this is a dynamic MBean", + new MBeanAttributeInfo[]{attributeInfo},null, + new MBeanOperationInfo[]{operationInfo},null); + } catch (Exception ex) { + System.out.println(ex); + } + return info; + } +} diff --git a/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/HelloWorldMBean.java b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/HelloWorldMBean.java new file mode 100644 index 0000000..28ed8fa --- /dev/null +++ b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/HelloWorldMBean.java @@ -0,0 +1,12 @@ +package com.heks.jmx; + +public interface HelloWorldMBean { + + String getHello(); + + void setHello(String hello); + + Object getInstance(); + + String message(String msg); +} diff --git a/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/JmxApplication.java b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/JmxApplication.java new file mode 100644 index 0000000..1208976 --- /dev/null +++ b/java-jmx/delombok/src-bak/src/main/java/com/heks/jmx/JmxApplication.java @@ -0,0 +1,13 @@ +package com.heks.jmx; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class JmxApplication { + + public static void main(String[] args) { + SpringApplication.run(JmxApplication.class, args); + } + +} diff --git a/java-jmx/delombok/src-bak/src/main/resources/application.properties b/java-jmx/delombok/src-bak/src/main/resources/application.properties new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/java-jmx/delombok/src-bak/src/main/resources/application.properties @@ -0,0 +1 @@ + diff --git a/java-jmx/delombok/src-bak/src/test/java/com/heks/jmx/JMXTest.java b/java-jmx/delombok/src-bak/src/test/java/com/heks/jmx/JMXTest.java new file mode 100644 index 0000000..9e0bdb5 --- /dev/null +++ b/java-jmx/delombok/src-bak/src/test/java/com/heks/jmx/JMXTest.java @@ -0,0 +1,65 @@ +package com.heks.jmx; + + +import org.junit.Test; +import org.omg.CORBA.PUBLIC_MEMBER; + +import javax.management.*; +import java.util.Set; + +public class JMXTest { + + /** + * 需要被管理的方法、属性等在接口中定义好，创建一个类，继承此接口，然后实现时候方法， + * 这样，但注册到MBeanServer的时候，会自动管理其，接口中的各个属性、方法。 + */ + @Test + public void test1StandardMBean() throws Exception { + MBeanServer ms = MBeanServerFactory.createMBeanServer(); + ObjectName name = new ObjectName("Hello:type=myfirstMbean"); + HelloWorld helloWorld = new HelloWorld("heks"); + + helloWorld.addNotificationListener(new NotificationListener() { + @Override + public void handleNotification(Notification notification, Object handback) { + System.out.println(" access listen : " + notification); + } + }, null, null); + + ms.registerMBean(helloWorld, name); + + String s1 = (String) ms.getAttribute(name, "Hello"); + System.out.println("the init value: " + s1); + + ms.setAttribute(name, new Attribute("Hello", "hi heks")); + String s2 = (String) ms.getAttribute(name, "Hello"); + System.out.println("the init value: " + s2); + + ms.invoke(name, "message", new Object[]{"i as message"}, new String[]{"java.lang.String"}); + ObjectName name2 = new ObjectName("*:*"); + Set set = ms.queryMBeans(name2, null); + System.out.println(set); + } + + /** + * 动态Mbean，需要实现DynamicMBean接口，并且任何需要，管理的方法、属性，都需要在接口的方法中， + * 自己来实现，Mbeaninfo也需要自己设置，这样编程的工作量大，但是有很大的可控性。 + * + * @throws Exception + */ + @Test + public void test2DynamicMBean() throws Exception { + HelloWorldDynamic dynamic = new HelloWorldDynamic(); + MBeanServer ms = MBeanServerFactory.createMBeanServer(); + ObjectName name = new ObjectName("DynamicHello:type=dinamicMbean"); + ms.registerMBean(dynamic, name); + + Object o = ms.getAttribute(name, "getInstance"); + String hello = (String) ms.getAttribute(name, "gh"); + MBeanOperationInfo operationInfo = dynamic.getMBeanInfo().getOperations()[0]; + System.out.println(" attribute value of getInstance:" + o + "; attribute value of gh:" + hello); + + ms.invoke(name, operationInfo.getName(), null, null); + } + +} diff --git a/java-jmx/delombok/src-bak/src/test/java/com/heks/jmx/JmxApplicationTests.java b/java-jmx/delombok/src-bak/src/test/java/com/heks/jmx/JmxApplicationTests.java new file mode 100644 index 0000000..cb2d8dd --- /dev/null +++ b/java-jmx/delombok/src-bak/src/test/java/com/heks/jmx/JmxApplicationTests.java @@ -0,0 +1,16 @@ +package com.heks.jmx; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.junit4.SpringRunner; + +@RunWith(SpringRunner.class) +@SpringBootTest +public class JmxApplicationTests { + + @Test + public void contextLoads() { + } + +} diff --git a/java-jmx/pom.xml b/java-jmx/pom.xml index 1f681ad..62a17d9 100644 --- a/java-jmx/pom.xml +++ b/java-jmx/pom.xml @@ -9,9 +9,9 @@ com.heks - jmx + java-jmx 0.0.1-SNAPSHOT - jmx + java-jmx Demo project for Spring Boot diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/aceessControler/MyFileInputStream.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/aceessControler/MyFileInputStream.java new file mode 100644 index 0000000..7b39634 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/aceessControler/MyFileInputStream.java @@ -0,0 +1,25 @@ +package som.hks.aceessControler; + +import java.io.File; +import java.io.FileNotFoundException; + +/** + * 第一步:编写MyFileInputStream + * (copy吧少年，不要自己狂敲) + */ +public class MyFileInputStream { + + public MyFileInputStream(String name) throws FileNotFoundException { + this(name != null ? new File(name) : null); + } + + public MyFileInputStream(File file) throws FileNotFoundException { + String name = (file != null ? file.getPath() : null); + SecurityManager security = System.getSecurityManager(); + if (security != null) { + security.checkRead(name); + } + } + + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/aceessControler/MySecurityManager.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/aceessControler/MySecurityManager.java new file mode 100644 index 0000000..c3663ce --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/aceessControler/MySecurityManager.java @@ -0,0 +1,16 @@ +package som.hks.aceessControler; + +/** + * 第一步：实现一个自己的类MySecurityManager，它继承自SecurityManager， + * 重写它的checkRead方法，我们直接让他抛出一个SecurityException异常。 + * (copy吧少年，要的是你知识的储备，不是要你把代码背下来) + */ +public class MySecurityManager extends SecurityManager{ + + @Override + public void checkRead(String file) { + //super.checkRead(file, context); + throw new SecurityException("你没有的权限"); + } + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/aceessControler/TestMySecurityManager.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/aceessControler/TestMySecurityManager.java new file mode 100644 index 0000000..e1d6b46 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/aceessControler/TestMySecurityManager.java @@ -0,0 +1,24 @@ +package som.hks.aceessControler; + +import java.io.IOException; + +/** + * 第二步：实现一个简单的类，主要用来测试我们自己定义的安全管理器起作用了没有， + * 我们这里借助了FileInputStream，因为FileInputStream会调用安全管理器去校验权限 + * 所以用FileInputStream测试我们自己的安全管理器非常的适合。 + */ +public class TestMySecurityManager { + + public static void main(String[] args) { + System.setSecurityManager(new MySecurityManager()); + try { + //FileInputStream fis = new FileInputStream("test"); + MyFileInputStream myFileInputStream = new MyFileInputStream("test"); + } catch (IOException e) { + e.printStackTrace(); + } + + } + + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/BigObj2Old.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/BigObj2Old.java new file mode 100644 index 0000000..49dbd38 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/BigObj2Old.java @@ -0,0 +1,19 @@ +package som.hks.oom; + +/** + * 软件开发过程中，应该尽可能避免使用短命的大对象。 + * 可以使用参数-XX:PetenureSizeThreshold 设置大对象直接进入年老代的阈值。 + * 当对象的大小超过这个值时，将直接在年老代分配。 + * 参数-XX:PetenureSizeThreshold 只对串行收集器和年轻代并行收集器有效，并行回收收集器不识别这个参数 + * + * -XX:+PrintGCDetails –Xmx20M –Xms20MB + * -XX:+PrintGCDetails –Xmx20M –Xms20MB -XX:PetenureSizeThreshold=1000000 + */ +public class BigObj2Old { + + public static void main(String[] args){ + byte[] b; + b = new byte[1024*1024];//分配一个 1MB 的对象 + } + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/EqualsOOMTest.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/EqualsOOMTest.java new file mode 100644 index 0000000..d304dd9 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/EqualsOOMTest.java @@ -0,0 +1,26 @@ +package som.hks.oom; + +public class EqualsOOMTest { + + /** + 说明： 对于 Integer var=? + 在-128 至 127 之间的赋值， Integer 对象是在IntegerCache.cache 产生，会复用已有对象， + 这个区间内的 Integer 值可以直接使用==进行判断， + + 但是这个区间之外的所有数据， + 都会在堆上产生，并不会复用已有对象 + */ + public static void main(String[] args){ + Integer i1 = 123; + Integer i2 = 123; + System.out.println(i1==i2); + Integer i3 = 129; + Integer i4 = 129; + System.out.println(i3==i4); + System.out.println(i3.equals(i4)); + int i5 = 130; + int i6 = 130; + System.out.println(i5==i6); + } + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/GCTimeTest.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/GCTimeTest.java new file mode 100644 index 0000000..017c828 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/GCTimeTest.java @@ -0,0 +1,31 @@ +package som.hks.oom; + +import java.util.HashMap; + +/** + * 所示代码运行 1 万次循环，每次分配 512*100B 空间， + * 采用不同的垃圾回收器，输出程序运行所消耗的时间 + */ +public class GCTimeTest { + + static HashMap map = new HashMap(); + + public static void main(String[] args){ + long begintime = System.currentTimeMillis(); + for(int i=0;i<10000;i++){ + if(map.size()*512/1024/1024>=400){ + //保护内存不溢出 + map.clear(); + System.out.println("clean map"); + } + byte[] b1; + for(int j=0;j<100;j++){ + b1 = new byte[512]; + map.put(System.nanoTime(), b1);//不断消耗内存 + } + } + long endtime = System.currentTimeMillis(); + System.out.println(endtime-begintime); + } + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/HeapSize.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/HeapSize.java new file mode 100644 index 0000000..98aa641 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/HeapSize.java @@ -0,0 +1,29 @@ +package som.hks.oom; + +import java.util.Vector; + +/** + * + -XX:MinHeapFreeRatio 参数用来设置堆空间最小空闲比例，默认值是 40。 + 当堆空间的空闲内存小于这个数值时，JVM 便会扩展堆空间。 + + -XX:MaxHeapFreeRatio 参数用来设置堆空间最大空闲比例，默认值是 70。 + 当堆空间的空闲内存大于这个数值时，便会压缩堆空间，得到一个较小的堆。 + + 当-Xmx 和-Xms 相等时，-XX:MinHeapFreeRatio 和-XX:MaxHeapFreeRatio 两个参数无效 + * -XX:+PrintGCDetails -Xms10M -Xmx40M -XX:MinHeapFreeRatio=40 -XX:MaxHeapFreeRatio=50 + * -XX:+PrintGCDetails -Xms40M -Xmx40M -XX:MinHeapFreeRatio=40 -XX:MaxHeapFreeRatio=50 + */ +public class HeapSize { + public static void main(String args[]) throws InterruptedException{ + Vector v = new Vector(); + while(true){ + byte[] b = new byte[1024*1024]; + v.add(b); + if(v.size() == 10){ + v = new Vector(); + } + Thread.sleep(1); + } + } +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/MaxTenuringThreshold.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/MaxTenuringThreshold.java new file mode 100644 index 0000000..5603bae --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/MaxTenuringThreshold.java @@ -0,0 +1,22 @@ +package som.hks.oom; + +/** + * 这个阈值的最大值可以通过参数-XX:MaxTenuringThreshold 来设置，默认值是 15。 + * 虽然-XX:MaxTenuringThreshold 的值可能是 15 或者更大，但这不意味着新对象非要达到这个年龄才能进入年老代。 + * 事实上，对象实际进入年老代的年龄是虚拟机在运行时根据内存使用情况动态计算的，这个参数指定的是阈值年龄的最大值。 + * 即，实际晋升年老代年龄等于动态计算所得的年龄与-XX:MaxTenuringThreshold 中较小的那个 + * + * -XX:+PrintGCDetails -Xmx20M -Xms20M -Xmn10M -XX:SurvivorRatio=2 + * + * -XX:+PrintGCDetails -Xmx20M -Xms20M -Xmn10M -XX:SurvivorRatio=2 -XX:MaxTenuringThreshold=1 + */ +public class MaxTenuringThreshold { + public static void main(String args[]){ + byte[] b1,b2,b3; + b1 = new byte[1024*512]; + b2 = new byte[1024*1024*2]; + b3 = new byte[1024*1024*4]; + b3 = null; + b3 = new byte[1024*1024*4]; + } +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/PutInEden.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/PutInEden.java new file mode 100644 index 0000000..81cd456 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/PutInEden.java @@ -0,0 +1,17 @@ +package som.hks.oom; + +/** + * 所示代码尝试分配 4MB 内存空间，观察一下它的内存使用情况 + */ +public class PutInEden { + + public static void main(String[] args){ + byte[] b1,b2,b3,b4;//定义变量 + //分配 1MB 堆空间，考察堆空间的使用情况 + b1=new byte[1024*1024]; + b2=new byte[1024*1024]; + b3=new byte[1024*1024]; + b4=new byte[1024*1024]; + } + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/PutInEden2.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/PutInEden2.java new file mode 100644 index 0000000..4b07353 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/PutInEden2.java @@ -0,0 +1,16 @@ +package som.hks.oom; + +/** + * -XX:+PrintGCDetails -Xmx1000M -Xms500M -Xmn100M -XX:SurvivorRatio=8 + * + */ +public class PutInEden2 { + public static void main(String[] args){ + byte[] b1,b2,b3; + b1=new byte[1024*512];//分配 0.5MB 堆空间 + b2=new byte[1024*1024*4];//分配 4MB 堆空间 + b3=new byte[1024*1024*4]; + b3=null; //使 b3 可以被回收 + b3=new byte[1024*1024*4];//分配 4MB 堆空间 + } +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/ReferenceTest.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/ReferenceTest.java new file mode 100644 index 0000000..63497de --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/oom/ReferenceTest.java @@ -0,0 +1,19 @@ +package som.hks.oom; + +public class ReferenceTest { + + public static void main(String[] args){ + String a = "1"; + String b = "2"; + String c = "3"; + a=b; + System.out.println(a+"\n"); + a=c; + System.out.println(a+"\n"); + c=null; + System.out.println(a+"\n"); + a=null; + System.out.println(a+"\n"); + } + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/CompileScript.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/CompileScript.java new file mode 100644 index 0000000..d54e696 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/CompileScript.java @@ -0,0 +1,48 @@ +package som.hks.script; + +import javax.script.*; + +import static java.lang.System.err; +import static java.lang.System.out; + +/** + * 让脚本运行得更快 + * + * 我们可以使用 ScriptEngine的compile方法进行编译。 + * + * 并不是所有脚本引擎都支持编译，只有实现了Compilable接口的脚本引擎才可以使用 compile进行编译， + * 否则将抛出一个错误。下面的例子将演示如何使用compile方法编译并运行javascript脚本。 + */ +public class CompileScript +{ + public static void main(String args[]) + { + ScriptEngineManager manager = new ScriptEngineManager(); + ScriptEngine engine = manager.getEngineByName("javascript"); + engine.put("counter", 0); // 向javascript传递一个参数 + // 判断这个脚本引擎是否支持编译功能 + if (engine instanceof Compilable) + { + Compilable compEngine = (Compilable)engine; + try + { + // 进行编译 + CompiledScript script = compEngine.compile("function count() { " + + " counter = counter +1; " + + " return counter; " + + "}; count();"); + out.printf("Counter: %s%n", script.eval()); + out.printf("Counter: %s%n", script.eval()); + out.printf("Counter: %s%n", script.eval()); + } + catch (ScriptException e) + { + err.println(e); + } + } + else + { + err.println("这个脚本引擎不支持编译!"); + } + } +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/FirstJavaScript.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/FirstJavaScript.java new file mode 100644 index 0000000..c6c22f2 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/FirstJavaScript.java @@ -0,0 +1,53 @@ +package som.hks.script; + +import javax.script.ScriptEngine; +import javax.script.ScriptEngineManager; +import javax.script.ScriptException; + +import static java.lang.System.err; +import static java.lang.System.out; + +/** + * 上面已经讨论了执行脚本的第一步，就是得到一个可用的脚本引擎。 + * 在完成这项工作之后就可以利用这个脚本引擎执行相应的脚本了。 + * + * 我们可以使用ScriptEngine的eval方法来执行脚本。 + * eval方法被重载的多次，但最常用的是 public Object eval(String script)。 + */ +public class FirstJavaScript +{ + public static void main(String args[]) + { + ScriptEngineManager manager = new ScriptEngineManager(); + // 得到javascript脚本引擎 + ScriptEngine engine = manager.getEngineByName("javascript"); + try + { + // 开始运行脚本，并返回当前的小时 + Double hour = (Double)engine.eval("var date = new Date();" +"date.getHours();"); + String msg; + // 将小时转换为问候信息 + if (hour < 11) + { + msg = "上午好"; + } + else if (hour < 13) + { + msg = "中午好"; + } + else if (hour < 18) + { + msg = "下午好"; + } + else + { + msg = "晚安"; + } + out.printf("小时%s: %s%n", hour, msg); + } + catch (ScriptException e) + { + err.println(e); + } + } +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/InterfaceTest.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/InterfaceTest.java new file mode 100644 index 0000000..c89a9e2 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/InterfaceTest.java @@ -0,0 +1,39 @@ +package som.hks.script; + +import javax.script.*; +import static java.lang.System.*; + +/** + * 动态实现接口 + * + * 脚本引擎还有一个更吸引的功能，那就是动态实现接口。 + * 如我们要想让脚本异步地执行，即通过多线程来执行， + * 那InvokeEngine类必须实现 Runnable接口才可以通过Thread启动多线程。 + * + * 因此，可以通过getInterface方法来使InvokeEngine动态地实现 Runnable接口。 + */ +public class InterfaceTest +{ + public static void main(String args[]) + { + ScriptEngineManager manager = new ScriptEngineManager(); + ScriptEngine engine = manager.getEngineByName("javascript"); + try + { + engine.eval("function run() {print('异步调用');}"); + Invocable invokeEngine = (Invocable)engine; + Runnable runner = invokeEngine.getInterface(Runnable.class); + Thread t = new Thread(runner); + t.start(); + t.join(); + } + catch (InterruptedException e) + { + err.println(e); + } + catch (ScriptException e) + { + System.err.println(e); + } + } +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/InvocableTest.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/InvocableTest.java new file mode 100644 index 0000000..693813c --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/InvocableTest.java @@ -0,0 +1,37 @@ +package som.hks.script; + +import javax.script.*; +import static java.lang.System.*; + +/** + * 动态调用脚本语言的方法 + * + * 但如果脚本中有多个函数或想通过用户的输入来决定调用哪个函数， + * 这就需要使用invoke方法进行动态调用。 + * 和编译一样，脚本引擎必须实现Invocable接口才可以动态调用脚本语言中的方法。 + */ +public class InvocableTest { + public static void main(String args[]) { + ScriptEngineManager manager = new ScriptEngineManager(); + ScriptEngine engine = manager.getEngineByName("javascript"); + String name = "abcdefg"; + if (engine instanceof Invocable) { + try { + engine.eval("function reverse(name) {" + + " var output =' ';" + + " for (i = 0; i <= name.length; i++) {" + + " output = name.charAt(i) + output" + + " } return output;}"); + Invocable invokeEngine = (Invocable) engine; + Object o = invokeEngine.invokeFunction("reverse", name); + out.printf("翻转后的字符串：%s", o); + } catch (NoSuchMethodException e) { + err.println(e); + } catch (ScriptException e) { + err.println(e); + } + } else { + err.println("这个脚本引擎不支持动态调用"); + } + } +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/ListScriptEngines.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/ListScriptEngines.java new file mode 100644 index 0000000..3ae21f2 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/ListScriptEngines.java @@ -0,0 +1,41 @@ +package som.hks.script; + +import javax.script.*; +import java.util.*; + +import static java.lang.System.*; + +/** + * 必须要知道你的Java SE 6支持什么脚本语言。 + * 在javax.script包中有很多的类，但这些类中最主要的是ScriptEngineManager。 + * 可以通过这个类得到当前 Java SE 6所支持的所有脚本。 + * + * 如下面例子将列出所有可以使用的脚本引擎工厂。 + */ +public class ListScriptEngines { + public static void main(String args[]) { + ScriptEngineManager manager = new ScriptEngineManager(); + // 得到所有的脚本引擎工厂 + List factories = manager.getEngineFactories(); + // 这是Java SE 5 和Java SE 6的新For语句语法 + for (ScriptEngineFactory factory : factories) { + // 打印脚本信息 + out.printf("Name: %s%n" + + "Version: %s%n" + + "Language name: %s%n" + + "Language version: %s%n" + + "Extensions: %s%n" + + "Mime types: %s%n" + + "Names: %s%n", + factory.getEngineName(), + factory.getEngineVersion(), + factory.getLanguageName(), + factory.getLanguageVersion(), + factory.getExtensions(), + factory.getMimeTypes(), + factory.getNames()); + // 得到当前的脚本引擎 + ScriptEngine engine = factory.getScriptEngine(); + } + } +} \ No newline at end of file diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/ReverseString.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/ReverseString.java new file mode 100644 index 0000000..3e70b73 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/script/ReverseString.java @@ -0,0 +1,41 @@ +package som.hks.script; + +import javax.script.ScriptEngine; +import javax.script.ScriptEngineManager; +import javax.script.ScriptException; + +import static java.lang.System.err; +import static java.lang.System.out; + +/** + * 和脚本语言进行交互 + * + * put 有两个参数，一个是脚本变量名，另一个是变量的值，这个值是Object类型，因此，可以传递任何值。 + * get 有一个参数，就是脚本变量的名。 + */ +public class ReverseString +{ + public static void main(String args[]) + { + ScriptEngineManager manager = new ScriptEngineManager(); + // 建立javascript脚本引擎 + ScriptEngine engine = manager.getEngineByName("javascript"); + try + { + // 将变量name和变量值abcdefg传给javascript脚本 + engine.put("name", "abcdefg"); + // 开始执行脚本 + engine.eval("var output ='' ;" + + "for (i = 0; i <= name.length; i++) {" + + " output = name.charAt(i) + output" + + "}"); + // 得到output变量的值 + String name = (String)engine.get("output"); + out.printf("被翻转后的字符串：%s", name); + } + catch (ScriptException e) + { + err.println(e); + } + } +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/securityManager/MySecurityManager.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/securityManager/MySecurityManager.java new file mode 100644 index 0000000..bcf8965 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/securityManager/MySecurityManager.java @@ -0,0 +1,16 @@ +package som.hks.securityManager; + +/** + * 第一步，定义一个类继承自SecurityManger重写它的checkRead方(如果你有兴趣可以先跳到super.checkRead(file, context); + * + */ +public class MySecurityManager extends SecurityManager{ + + @Override + public void checkRead(String file) { + //super.checkRead(file, context); + if (file.endsWith("test")) + throw new SecurityException("你没有读取的本文件的权限"); + } + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/securityManager/TestMySecurityManager.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/securityManager/TestMySecurityManager.java new file mode 100644 index 0000000..6797e24 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/securityManager/TestMySecurityManager.java @@ -0,0 +1,27 @@ +package som.hks.securityManager; + +import java.io.FileInputStream; +import java.io.IOException; + +/** + * 第二步，定义一个有main函数的public类来验证自己的安全管理器是不是器作用了。 + */ +public class TestMySecurityManager { + + public static void main(String[] args) { + System.setSecurityManager(new MySecurityManager()); + try { + FileInputStream fis = new FileInputStream("test"); + System.out.println(fis.read()); + } catch (IOException e) { + e.printStackTrace(); + } + + } + + /** + * 第三步，运行代码查看控制台输出 + */ + + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/Doer.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/Doer.java new file mode 100644 index 0000000..58d32f7 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/Doer.java @@ -0,0 +1,8 @@ +package som.hks.stackAccess; + + +public abstract interface Doer { + + void doYourThing(); + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/Friend.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/Friend.java new file mode 100644 index 0000000..48ded89 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/Friend.java @@ -0,0 +1,36 @@ +package som.hks.stackAccess; + +import java.security.AccessController; +import java.security.PrivilegedAction; + +public class Friend implements Doer{ + + private Doer next; + private boolean direct; + + public Friend(Doer next,boolean direct){ + this.next=next; + this.direct=direct; + } + + @Override + public void doYourThing() { + System.out.println("Im a Friend"); + + if (direct) { + next.doYourThing(); + } else { + AccessController.doPrivileged(new PrivilegedAction() { + + @Override + public Object run() { + next.doYourThing(); + return null; + } + + }); + + } + } + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/Stranger.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/Stranger.java new file mode 100644 index 0000000..12f938a --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/Stranger.java @@ -0,0 +1,37 @@ +package som.hks.stackAccess; + +import java.security.AccessController; +import java.security.PrivilegedAction; + +public class Stranger implements Doer { + + private Doer next; + private boolean direct; + + public Stranger(Doer next, boolean direct) { + this.next = next; + this.direct = direct; + } + + @Override + public void doYourThing() { + System.out.println("Im a Stranger"); + + if (direct) { + next.doYourThing(); + } else { + AccessController.doPrivileged(new PrivilegedAction() { + + @Override + public Object run() { + next.doYourThing(); + return null; + } + + }); + + } + } + + +} diff --git a/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/TextFileDisplayer.java b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/TextFileDisplayer.java new file mode 100644 index 0000000..eb6d986 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/main/java/som/hks/stackAccess/TextFileDisplayer.java @@ -0,0 +1,45 @@ +package som.hks.stackAccess; + +import java.io.CharArrayWriter; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; + +public class TextFileDisplayer implements Doer{ + + String fileName; + public TextFileDisplayer(String fileName){ + this.fileName=fileName; + } + @Override + public void doYourThing() { + try { + FileReader fr = new FileReader(fileName); + try { + CharArrayWriter caw = new CharArrayWriter(); + int c; + while((c=fr.read())!=-1){ + caw.write(c); + } + System.out.println(caw.toString()); + } catch (IOException e) { + e.printStackTrace(); + }finally{ + if(fr!=null){ + try { + fr.close(); + fr=null; + } catch (IOException e) { + e.printStackTrace(); + } + + } + } + } catch (FileNotFoundException e) { + e.printStackTrace(); + } + + } + + +} diff --git a/java-jvmpre/delombok/src-bak/src/test/java/com/hks/DirectMemoryOOM.java b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/DirectMemoryOOM.java new file mode 100644 index 0000000..90db225 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/DirectMemoryOOM.java @@ -0,0 +1,19 @@ +package com.hks; + +import sun.misc.Unsafe; + +import java.lang.reflect.Field; + +//-XX:MaxDirectMemorySize=10M +public class DirectMemoryOOM { + private static final int _1MB = 1024*1024; + + public static void main(String[] args) throws Exception{ + Field unsafefield = Unsafe.class.getDeclaredFields()[0]; + unsafefield.setAccessible(true); + Unsafe unsafe = (Unsafe) unsafefield.get(null); + while (true){ + unsafe.allocateMemory(_1MB); + } + } +} diff --git a/java-jvmpre/delombok/src-bak/src/test/java/com/hks/HeapAllocation.java b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/HeapAllocation.java new file mode 100644 index 0000000..f42799b --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/HeapAllocation.java @@ -0,0 +1,14 @@ +package com.hks; + +public class HeapAllocation { + + private static final int _1MB = 1024 * 1024; + + public static void main(String[] args) { + byte[] allocation1, allocation2, allocation3, allocation4; + allocation1 = new byte[2 * _1MB]; + allocation2 = new byte[2 * _1MB]; + allocation3 = new byte[2 * _1MB]; + allocation4 = new byte[4 * _1MB]; + } +} diff --git a/java-jvmpre/delombok/src-bak/src/test/java/com/hks/HeapOOM.java b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/HeapOOM.java new file mode 100644 index 0000000..1ae5be5 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/HeapOOM.java @@ -0,0 +1,16 @@ +package com.hks; + +import java.util.ArrayList; +import java.util.List; + +//-Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 +public class HeapOOM { + static class OOMObject{} + + public static void main(String[] args) { + List list = new ArrayList(); + while (true){ + list.add(new OOMObject()); + } + } +} diff --git a/java-jvmpre/delombok/src-bak/src/test/java/com/hks/JavaVMStackSOF.java b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/JavaVMStackSOF.java new file mode 100644 index 0000000..0414dd1 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/JavaVMStackSOF.java @@ -0,0 +1,21 @@ +package com.hks; + +//-Xss160k +public class JavaVMStackSOF { + private int stackLength = 1; + + public void stackLeak(){ + stackLength++; + stackLeak(); + } + + public static void main(String[] args) throws Throwable{ + JavaVMStackSOF oom = new JavaVMStackSOF(); + try{ + oom.stackLeak(); + } catch (Exception ex){ + System.out.println(ex.getStackTrace().length); + throw ex; + } + } +} diff --git a/java-jvmpre/delombok/src-bak/src/test/java/com/hks/RuntimeConstantPoolOOM.java b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/RuntimeConstantPoolOOM.java new file mode 100644 index 0000000..a503260 --- /dev/null +++ b/java-jvmpre/delombok/src-bak/src/test/java/com/hks/RuntimeConstantPoolOOM.java @@ -0,0 +1,15 @@ +package com.hks; + +import java.util.ArrayList; +import java.util.List; + +//-XX:PermSize=10M -XX:MaxPermSize=10M +public class RuntimeConstantPoolOOM { + public static void main(String[] args) { + List list = new ArrayList(); + int i =0; + while (true){ + list.add(String.valueOf(i).intern()); + } + } +} diff --git a/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/FilterTest.java b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/FilterTest.java new file mode 100644 index 0000000..303ffe0 --- /dev/null +++ b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/FilterTest.java @@ -0,0 +1,22 @@ +package com.hks.lambda; + +import org.junit.Test; + +import java.util.Arrays; +import java.util.stream.Stream; + +public class FilterTest { + + /** + * filter 对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream。 + */ + @Test + public void simpleFilterTest(){ + Integer[] sixNums = {1, 2, 3, 4, 5, 6}; + Integer[] evens = + Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new); + + Arrays.stream(evens).forEach(System.out::println); + } + +} diff --git a/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/FindFirstTest.java b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/FindFirstTest.java new file mode 100644 index 0000000..f76f220 --- /dev/null +++ b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/FindFirstTest.java @@ -0,0 +1,49 @@ +package com.hks.lambda; + +import org.junit.Test; + +import java.util.Optional; + +/** + * findFirst这是一个 termimal 兼 short-circuiting 操作，它总是返回 Stream 的第一个元素，或者空 + */ +public class FindFirstTest { + + String strA = " abcd ", strB = null; + + /** + * 这里比较重点的是它的返回值类型：Optional。 + * 这也是一个模仿 Scala 语言中的概念，作为一个容器，它可能含有某值，或者不包含。 + * 使用它的目的是尽可能避免 NullPointerException。 + */ + @Test + public void test(){ + print(strA); + System.out.println("--"); + print(""); + System.out.println("--"); + print(strB); + System.out.println("--"); + System.out.println(getLength(strA)); + System.out.println("--"); + System.out.println(getLength("")); + System.out.println("--"); + System.out.println(getLength(strB)); + } + + public static void print(String text) { + // Java 8 + Optional.ofNullable(text).ifPresent(System.out::println); + // Pre-Java 8 + if (text != null) { + System.out.println(text); + } + } + + public static int getLength(String text) { + // Java 8 + return Optional.ofNullable(text).map(String::length).orElse(-1); + // Pre-Java 8 +// return if (text != null) ? text.length() : -1; + }; +} diff --git a/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/LimitSkipTest.java b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/LimitSkipTest.java new file mode 100644 index 0000000..e5938ed --- /dev/null +++ b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/LimitSkipTest.java @@ -0,0 +1,56 @@ +package com.hks.lambda; + +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +public class LimitSkipTest { + + @Test + public void testLimitAndSkip() { + List persons = new ArrayList(); + for (int i = 1; i <= 10000; i++) { + Person person = new Person(i, "name" + i); + persons.add(person); + } + List personList2 = persons.stream(). + map(Person::getName).limit(10).skip(3).collect(Collectors.toList()); + System.out.println(personList2); + } + + /** + * 有一种情况是 limit/skip 无法达到 short-circuiting 目的的， + * 就是把它们放在 Stream 的排序操作后，原因跟 sorted 这个 intermediate 操作有关： + * 此时系统并不知道 Stream 排序后的次序如何，所以 sorted 中的操作看上去就像完全没有被 limit 或者 skip 一样。 + * + * 对 Stream 的排序通过 sorted 进行， + * 它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序， + * 这能帮助程序明显缩短执行时间。 + */ + @Test + public void testSort(){ + List persons = new ArrayList(); + for (int i = 1; i <= 5; i++) { + Person person = new Person(i, "name" + i); + persons.add(person); + } + //List personList2 = persons.stream().sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).limit(2).collect(Collectors.toList()); + List personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).collect(Collectors.toList()); + System.out.println(personList2); + } + + private class Person { + public int no; + private String name; + public Person (int no, String name) { + this.no = no; + this.name = name; + } + public String getName() { + System.out.println(name); + return name; + } + } +} diff --git a/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/MapReflectTest.java b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/MapReflectTest.java new file mode 100644 index 0000000..9c82ab2 --- /dev/null +++ b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/MapReflectTest.java @@ -0,0 +1,41 @@ +package com.hks.lambda; + +import org.junit.Test; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class MapReflectTest { + + /** + * map 生成的是个 1:1 映射，每个输入元素，都按照规则转换成为另外一个元素。 + */ + @Test + public void oneToOneTest(){ + List nums = Arrays.asList(1, 2, 3, 4); + List squareNums = nums.stream(). + map(n -> n * n). + collect(Collectors.toList()); + + squareNums.forEach(System.out::println); + } + + /** + * 还有一些场景，是一对多映射关系的，这时需要 flatMap。 + */ + @Test + public void oneToManyTest(){ + Stream> inputStream = Stream.of( + Arrays.asList(1), + Arrays.asList(2, 3), + Arrays.asList(4, 5, 6) + ); + Stream outputStream = inputStream. + flatMap((childList) -> childList.stream()); + + outputStream.forEach(System.out::println); + } + +} diff --git a/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/MatchTest.java b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/MatchTest.java new file mode 100644 index 0000000..1b12899 --- /dev/null +++ b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/MatchTest.java @@ -0,0 +1,47 @@ +package com.hks.lambda; + +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; + +public class MatchTest { + + @Test + public void matchTest() { + List persons = new ArrayList(); + persons.add(new Person(1, "name" + 1, 10)); + persons.add(new Person(2, "name" + 2, 21)); + persons.add(new Person(3, "name" + 3, 34)); + persons.add(new Person(4, "name" + 4, 6)); + persons.add(new Person(5, "name" + 5, 55)); + boolean isAllAdult = persons.stream(). + allMatch(p -> p.getAge() > 18); + System.out.println("All are adult? " + isAllAdult); + boolean isThereAnyChild = persons.stream(). + anyMatch(p -> p.getAge() < 12); + System.out.println("Any child? " + isThereAnyChild); + } + + private class Person { + public int no; + private String name; + private int age; + + public Person(int no, String name, int age) { + this.no = no; + this.name = name; + this.age = age; + } + + public String getName() { + System.out.println(name); + return name; + } + + public int getAge() { + System.out.println(age); + return age; + } + } +} diff --git a/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/PeekTest.java b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/PeekTest.java new file mode 100644 index 0000000..05b34f2 --- /dev/null +++ b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/PeekTest.java @@ -0,0 +1,27 @@ +package com.hks.lambda; + +import org.junit.Test; + +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class PeekTest { + + + + /** + * forEach 是 terminal 操作，因此它执行后，Stream 的元素就被“消费”掉了，你无法对一个 Stream 进行两次 terminal 运算。 + * + * 相反，具有相似功能的 intermediate 操作 peek 可以达到上述目的。 + */ + @Test + public void foreachPeekTest(){ + Stream.of("one", "two", "three", "four") + .filter(e -> e.length() > 3) + .peek(e -> System.out.println("Filtered value: " + e)) + .map(String::toUpperCase) + .peek(e -> System.out.println("Mapped value: " + e)) + .collect(Collectors.toList()); + } + +} diff --git a/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/ReduceTest.java b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/ReduceTest.java new file mode 100644 index 0000000..aa1e572 --- /dev/null +++ b/java-lambda/delombok/src-bak/src/main/java/com/hks/lambda/ReduceTest.java @@ -0,0 +1,35 @@ +package com.hks.lambda; + +import org.junit.Test; + +import java.util.stream.Stream; + +/** + * 这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator）， + * + * 和前面 Stream 的第一个、第二个、第 n 个元素组合。 + * 从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。 + */ +public class ReduceTest { + + @Test + public void reduceTest(){ + String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); + System.out.print(concat+"\r\n"); +// 求最小值，minValue = -3.0 + double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); + System.out.print(minValue+"\r\n"); +// 求和，sumValue = 10, 有起始值 + int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum); + System.out.print(sumValue+"\r\n"); +// 求和，sumValue = 10, 无起始值 + sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get(); + System.out.print(sumValue+"\r\n"); +// 过滤，字符串连接，concat = "ace" + concat = Stream.of("a", "B", "c", "D", "e", "F"). + filter(x -> x.compareTo("Z") > 0). + reduce("", String::concat); + System.out.print(concat+"\r\n"); + } + +} diff --git a/java-lock/delombok/src-bak/src/main/java/com/hks/lock/Test.java b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/Test.java new file mode 100644 index 0000000..2785bbd --- /dev/null +++ b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/Test.java @@ -0,0 +1,14 @@ +/* + * 文件名：Test.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/26 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.lock; + +public class Test { +} diff --git a/java-lock/delombok/src-bak/src/main/java/com/hks/lock/reentrant/ReentrantTest.java b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/reentrant/ReentrantTest.java new file mode 100644 index 0000000..ae30b40 --- /dev/null +++ b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/reentrant/ReentrantTest.java @@ -0,0 +1,41 @@ +/* + * 文件名：ReentrantTest.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/26 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.lock.reentrant; + +import java.util.concurrent.locks.ReentrantLock; + +public class ReentrantTest implements Runnable{ + ReentrantLock lock = new ReentrantLock(); + + public void get() { + lock.lock(); + System.out.println(Thread.currentThread().getId()); + set(); + lock.unlock(); + } + + public void set() { + lock.lock(); + System.out.println(Thread.currentThread().getId()); + lock.unlock(); + } + + public void run() { + get(); + } + + public static void main(String[] args) { + ReentrantTest ss = new ReentrantTest(); + new Thread(ss).start(); + new Thread(ss).start(); + new Thread(ss).start(); + } +} diff --git a/java-lock/delombok/src-bak/src/main/java/com/hks/lock/reentrant/SynchronizedTest.java b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/reentrant/SynchronizedTest.java new file mode 100644 index 0000000..94a83fd --- /dev/null +++ b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/reentrant/SynchronizedTest.java @@ -0,0 +1,33 @@ +/* + * 文件名：SynchrosizedTest.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/26 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.lock.reentrant; + +public class SynchronizedTest implements Runnable { + public synchronized void get() { + System.out.println(Thread.currentThread().getId()); + set(); + } + + public synchronized void set() { + System.out.println(Thread.currentThread().getId()); + } + + public void run() { + get(); + } + + public static void main(String[] args) { + SynchronizedTest ss = new SynchronizedTest(); + new Thread(ss).start(); + new Thread(ss).start(); + new Thread(ss).start(); + } +} diff --git a/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLock.java b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLock.java new file mode 100644 index 0000000..86e9b0c --- /dev/null +++ b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLock.java @@ -0,0 +1,36 @@ +/* + * 文件名：SpinLock.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/26 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.lock.spinLock; + +import java.util.concurrent.atomic.AtomicReference; + +/** + * 对于自旋锁来说， + 1、若有同一线程两调用lock() ，会导致第二次调用lock位置进行自旋，产生了死锁 + 说明这个锁并不是可重入的。（在lock函数内，应验证线程是否为已经获得锁的线程） + 2、若1问题已经解决，当unlock（）第一次调用时，就已经将锁释放了。实际上不应释放锁。 + （采用计数次进行统计） + */ +public class SpinLock { + private AtomicReference owner =new AtomicReference(); + + public void lock(){ + Thread current = Thread.currentThread(); + while(!owner.compareAndSet(null, current)){ + } + } + + public void unlock (){ + Thread current = Thread.currentThread(); + owner.compareAndSet(current, null); + } +} + diff --git a/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLock1.java b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLock1.java new file mode 100644 index 0000000..c2e5017 --- /dev/null +++ b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLock1.java @@ -0,0 +1,42 @@ +/* + * 文件名：SpinLock1.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/26 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.lock.spinLock; + +import java.util.concurrent.atomic.AtomicReference; + +public class SpinLock1 { + private AtomicReference owner =new AtomicReference(); + private int count =0; + public void lock(){ + Thread current = Thread.currentThread(); + if(current==owner.get()) { + count++; + return ; + } + + while(!owner.compareAndSet(null, current)){ + + } + } + public void unlock (){ + Thread current = Thread.currentThread(); + if(current==owner.get()){ + if(count!=0){ + count--; + }else{ + owner.compareAndSet(current, null); + } + + } + + } +} + diff --git a/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLock1Test.java b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLock1Test.java new file mode 100644 index 0000000..c91729e --- /dev/null +++ b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLock1Test.java @@ -0,0 +1,39 @@ +/* + * 文件名：SpinLock1Test.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/26 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.lock.spinLock; + +public class SpinLock1Test implements Runnable{ + SpinLock1 lock = new SpinLock1(); + + public void get() { + lock.lock(); + System.out.println(Thread.currentThread().getId()); + set(); + lock.unlock(); + } + + public void set() { + lock.lock(); + System.out.println(Thread.currentThread().getId()); + lock.unlock(); + } + + public void run() { + get(); + } + + public static void main(String[] args) { + SpinLock1Test ss = new SpinLock1Test(); + new Thread(ss).start(); + new Thread(ss).start(); + new Thread(ss).start(); + } +} diff --git a/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLockTest.java b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLockTest.java new file mode 100644 index 0000000..b14cd8e --- /dev/null +++ b/java-lock/delombok/src-bak/src/main/java/com/hks/lock/spinLock/SpinLockTest.java @@ -0,0 +1,39 @@ +/* + * 文件名：SpinLockTest.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/26 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.lock.spinLock; + +public class SpinLockTest implements Runnable{ + SpinLock lock = new SpinLock(); + + public void get() { + lock.lock(); + System.out.println(Thread.currentThread().getId()); + set(); + lock.unlock(); + } + + public void set() { + lock.lock(); + System.out.println(Thread.currentThread().getId()); + lock.unlock(); + } + + public void run() { + get(); + } + + public static void main(String[] args) { + SpinLockTest ss = new SpinLockTest(); + new Thread(ss).start(); + new Thread(ss).start(); + new Thread(ss).start(); + } +} diff --git a/java-network/Cidr.class b/java-network/Cidr.class new file mode 100644 index 0000000..e90c833 Binary files /dev/null and b/java-network/Cidr.class differ diff --git a/java-network/Cidr.java b/java-network/Cidr.java new file mode 100644 index 0000000..af26e7b --- /dev/null +++ b/java-network/Cidr.java @@ -0,0 +1,366 @@ +/* + * @Author: 阿拉斯加大闸蟹 hekuangsheng@163.com + * @Date: 2023-02-03 03:04:20 + * @LastEditors: 阿拉斯加大闸蟹 hekuangsheng@163.com + * @LastEditTime: 2023-02-03 03:09:30 + * @FilePath: /java-base/java-network/cidr.java + * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE + */ +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.regex.Pattern; + +public class Cidr { + + public static void main(String[] args) { + System.err.println(subnetDivide("117.72.16.0/23",9)); + } + + /*** + * 判断一个数是否是2的次幂 + * @param n + * @return + */ + public static boolean isPowerOfTwo(int n) { + String str = Integer.toBinaryString(n); + if(n < 1) { + return false; + } else if(str.lastIndexOf("1") == 0) { + return true; + } else { + return false; + } + } + + +// public static String toBinary(String str){ //把字符串转成字符数组 +// char[] strChar=str.toCharArray(); +// String result=""; +// for(int i=0;i> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v++; + return v; + } + + /*** + * 2的次幂 + * @param n 次幂 + * @return + */ + private static int calculate2Num(int n) { + if (n == 0) { + return 1; + } + return 2 * calculate2Num(n - 1); + } + /*** + * 具体划分步骤 + * @return + */ + public static List divideByPow(String ips,int pow){ +// Map map=new HashMap<>(); + List ipList = new ArrayList(); + try { + if(ips ==null || "".equals(ips.trim()) || "null".equals(ips.trim())){ + return ipList; + } + ips = ips.trim(); + if(ips.indexOf("/")>0) { + String temp[] = ips.split("/"); + if(temp.length == 2 && isIP(temp[0])){ + String ip=temp[0]; + String subnet=temp[1]; + String ipBitStr = makeBinaryString( getIpFromString(ip).intValue()); + int leg = ipBitStr.length(); + int bitNum = Integer.parseInt(subnet); + String str0 = "00000000000000000000000000000000"; + String str1 = "11111111111111111111111111111111"; + if(bitNum <= 32){ + String startIPBit = ipBitStr.substring(0, leg-(32-bitNum))+str0.substring(0, 32-bitNum); + String endIPBit = ipBitStr.substring(0, leg-(32-bitNum))+str1.substring(0, 32-bitNum); + Long startIPLong = getIpFromString(getIpStringFrom10bit(startIPBit)); + Long endIPLong = getIpFromString(getIpStringFrom10bit(endIPBit)); + Integer midNum=Integer.valueOf(1+str0.substring(0, 32-(bitNum+pow)), 2); + int subnetT=bitNum+pow; + for (int i = 0; i < calculate2Num(pow); i++) { +// map.put(getIpFromLong(startIPLong)+"/"+subnetT,getIpFromLong(startIPLong)+"/"+subnetT); + ipList.add(getIpFromLong(startIPLong)+"/"+subnetT); + startIPLong+=midNum; + } + } + +// System.err.println(ipList+"--------------"); + } + } + return ipList; + } catch (Exception e) { + return ipList; + } + } + /*** + * 小于等于2的次幂的最大值 + * @param subNum 划分数目 + * @return pow 2的几次幂 + */ + public static int judge(int subNum) { + int pow=0; + if(isPowerOfTwo(subNum)) {//是否是2的次幂 + pow=(int) (Math.log(subNum)/Math.log(2));//2的几次幂 + }else { + pow=roundup_power_of_2(subNum)/2;//小于等于2的次幂的最大值 + pow=(int) (Math.log(pow)/Math.log(2)); + } + return pow; + } + + + /*** + * 子网划分 + * @param ips 网段192.168.0.0/22 + * @param subNum 子网划分数量 + * @return + */ + public static List subnetDivide(String ips,int subNum) { + List ipList = new ArrayList(); + if(subNum>1){ + int pow =judge(subNum); + int difference=subNum-calculate2Num(pow); + ipList =divideByPow(ips,pow);//第一次划分 + if(difference!=0) { + while (difference>0) { + if(difference==1) { + difference--; + ipList.addAll(divideByPow(ipList.get(0),1)); + ipList.remove(ipList.get(0)); + }else { + pow =judge(difference); + difference=difference-calculate2Num(pow); + for (int i = 0; i < calculate2Num(pow); i++) { + ipList.addAll(divideByPow(ipList.get(0),pow)); + ipList.remove(ipList.get(0)); + } + + } + } + } + }else { + ipList.add(ips); + } + return ipList; + } + + /** + * 把long类型的Ip转为一般Ip类型：xx.xx.xx.xx + * + * @param ip + * @return + */ + public static String getIpFromLong(Long ip) + { + String s1 = String.valueOf((ip & 4278190080L) / 16777216L); + String s2 = String.valueOf((ip & 16711680L) / 65536L); + String s3 = String.valueOf((ip & 65280L) / 256L); + String s4 = String.valueOf(ip & 255L); + return s1 + "." + s2 + "." + s3 + "." + s4; + } + /** + * 把xx.xx.xx.xx类型的转为long类型的 + * + * @param ip + * @return + */ + public static Long getIpFromString(String ip) + { + Long ipLong = 0L; + String ipTemp = ip; + ipLong = ipLong * 256 + + Long.parseLong(ipTemp.substring(0, ipTemp.indexOf('.'))); + ipTemp = ipTemp.substring(ipTemp.indexOf('.') + 1, ipTemp.length()); + ipLong = ipLong * 256 + + Long.parseLong(ipTemp.substring(0, ipTemp.indexOf('.'))); + ipTemp = ipTemp.substring(ipTemp.indexOf(".") + 1, ipTemp.length()); + ipLong = ipLong * 256 + + Long.parseLong(ipTemp.substring(0, ipTemp.indexOf('.'))); + ipTemp = ipTemp.substring(ipTemp.indexOf('.') + 1, ipTemp.length()); + ipLong = ipLong * 256 + Long.parseLong(ipTemp); + return ipLong; + } + /** + * 根据掩码位获取掩码 + * + * @param maskBit + * 掩码位数，如"28"、"30" + * @return + */ + public static String getMaskByMaskBit(String maskBit) + { + return "".equals(maskBit) ? "error, maskBit is null !" : getMaskMap(maskBit); + } + + /** + * 根据 ip/掩码位 计算IP段的起始IP 如 IP串 218.240.38.69/30 + * + * @param ip + * 给定的IP，如218.240.38.69 + * @param maskBit + * 给定的掩码位，如30 + * @return 起始IP的字符串表示 + */ + public static String getBeginIpStr(String ip, String maskBit) + { + return getIpFromLong(getBeginIpLong(ip, maskBit)); + } + /** + * 根据 ip/掩码位 计算IP段的起始IP 如 IP串 218.240.38.69/30 + * + * @param ip + * 给定的IP，如218.240.38.69 + * @param maskBit + * 给定的掩码位，如30 + * @return 起始IP的长整型表示 + */ + public static Long getBeginIpLong(String ip, String maskBit) + { + return getIpFromString(ip) & getIpFromString(getMaskByMaskBit(maskBit)); + } + /** + * 根据 ip/掩码位 计算IP段的终止IP 如 IP串 218.240.38.69/30 + * + * @param ip + * 给定的IP，如218.240.38.69 + * @param maskBit + * 给定的掩码位，如30 + * @return 终止IP的字符串表示 + */ + public static String getEndIpStr(String ip, String maskBit) + { + return getIpFromLong(getEndIpLong(ip, maskBit)); + } + + /** + * 根据 ip/掩码位 计算IP段的终止IP 如 IP串 218.240.38.69/30 + * + * @param ip + * 给定的IP，如218.240.38.69 + * @param maskBit + * 给定的掩码位，如30 + * @return 终止IP的长整型表示 + */ + public static Long getEndIpLong(String ip, String maskBit) + { + return getBeginIpLong(ip, maskBit) + + ~getIpFromString(getMaskByMaskBit(maskBit)); + } + + public static String getMaskMap(String maskBit) { + switch (maskBit){ + case "1" : return "128.0.0.0"; + case "2" : return "192.0.0.0"; + case "3" : return "224.0.0.0"; + case "4" : return "240.0.0.0"; + case "5" : return "248.0.0.0"; + case "6" : return "252.0.0.0"; + case "7" : return "254.0.0.0"; + case "8" : return "255.0.0.0"; + case "9" : return "255.128.0.0"; + case "10" : return "255.192.0.0"; + case "11" : return "255.224.0.0"; + case "12" : return "255.240.0.0"; + case "13" : return "255.248.0.0"; + case "14" : return "255.252.0.0"; + case "15" : return "255.254.0.0"; + case "16" : return "255.255.0.0"; + case "17" : return "255.255.128.0"; + case "18" : return "255.255.192.0"; + case "19" : return "255.255.224.0"; + case "20" : return "255.255.240.0"; + case "21" : return "255.255.248.0"; + case "22" : return "255.255.252.0"; + case "23" : return "255.255.254.0"; + case "24" : return "255.255.255.0"; + case "25" : return "255.255.255.128"; + case "26" : return "255.255.255.192"; + case "27" : return "255.255.255.224"; + case "28" : return "255.255.255.240"; + case "29" : return "255.255.255.248"; + case "30" : return "255.255.255.252"; + case "31" : return "255.255.255.254"; + case "32" : return "255.255.255.255"; + default: return "-1"; + } + } + + + /** + * 十进制转换成二进制 + */ + public static String makeBinaryString(int i){ + String binary = ""; + do{ + int Bit = (i & 1); + String newDigit = ((Bit == 0) ? "0" : "1"); + binary = newDigit + binary; + i >>>= 1; + }while (i != 0); + return binary; + } + + /** + * + * 输入从10进制转换过来的2进制，再转换成ip地址 + * @return + */ + public static String getIpStringFrom10bit(String ss) + { + while(ss.length() <32 ){ + ss = "0"+ss ; + } + + String[] ssArray =new String [8]; + + ssArray[0]=ss.substring(0, 8); + ssArray[1]=ss.substring(8, 16); + ssArray[2]=ss.substring(16, 24); + ssArray[3]=ss.substring(24, 32); + + String sttttt= + Integer.valueOf(ssArray[0],2).toString() + +'.'+Integer.valueOf(ssArray[1],2).toString() + +'.'+Integer.valueOf(ssArray[2],2).toString() + +'.'+Integer.valueOf(ssArray[3],2).toString(); + + return sttttt; + } + + /** + * 功能：根据位数返回IP总数 + * 格式：isIP("192.192.192.1") + */ + public static boolean isIP(String str) { + String regex = "\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"; + Pattern pattern = Pattern.compile(regex); + return pattern.matcher(str).matches(); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/EnchaseTest.java b/java-object/delombok/src-bak/src/main/java/com/hks/EnchaseTest.java new file mode 100644 index 0000000..8c56dea --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/EnchaseTest.java @@ -0,0 +1,41 @@ +package com.hks; + +/** + * @author Dale + * java中的自动装箱与拆箱 + * 简单一点说，装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。 + */ +public class EnchaseTest { + + public static void main(String[] args) { + /** + Integer i1 = 128; // 装箱，相当于 Integer.valueOf(128); + int t = i1; //相当于 i1.intValue() 拆箱 + System.out.println(t); + */ + + /** + 对于–128到127（默认是127）之间的值,被装箱后，会被放在内存里进行重用 + 但是如果超出了这个值,系统会重新new 一个对象 + */ + Integer i1 = 200; + Integer i2 = 200; + + /** + 注意 == 与 equals的区别 + == 它比较的是对象的地址 + equals 比较的是对象的内容 + */ + if(i1==i2) { + System.out.println("true"); + } else { + System.out.println("false"); + } + + Integer a=123; + Integer b=123; + System.out.println(a==b); // 输出 true + System.out.println(a.equals(b)); // 输出 true + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/EncodeTest.java b/java-object/delombok/src-bak/src/main/java/com/hks/EncodeTest.java new file mode 100644 index 0000000..8bd15b8 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/EncodeTest.java @@ -0,0 +1,34 @@ +package com.hks; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.charset.Charset; + +public class EncodeTest { + + public static void main(String[] ags){ + try{ + String s = "这是一段中文字符串"; + byte[] b = s.getBytes("UTF-8"); + String n = new String(b,"UTF-8"); + System.out.print(n); + + /*ByteToCharConverter charConverter = ByteToCharConverter.getConverter("UTF-8"); + char c[] = charConverter.convertAll(byteArray); + CharToByteConverter byteConverter = CharToByteConverter.getConverter("UTF-8"); + byte[] b = byteConverter.convertAll(c);*/ + + Charset charset = Charset.forName("UTF-8"); + ByteBuffer byteBuffer = charset.encode(n); + CharBuffer charBuffer = charset.decode(byteBuffer); + System.out.print(charBuffer); + + ByteBuffer heapByteBuffer = ByteBuffer.allocate(1024); + ByteBuffer byteBuffer1 = heapByteBuffer.putChar(n.charAt(0)); + System.out.print(byteBuffer1); + }catch (Exception ex){ + ex.printStackTrace(); + } + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/FinallyDemo.java b/java-object/delombok/src-bak/src/main/java/com/hks/FinallyDemo.java new file mode 100644 index 0000000..2aade5b --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/FinallyDemo.java @@ -0,0 +1,43 @@ +package com.hks; + +public class FinallyDemo { + + public static void main(String[] args){ + System.out.println(m_1()); + System.out.println(m_2()); + } + + public static int m_1(){ + int i = 10; + try{ + System.out.println("start"); + return i += 10; + }catch(Exception e){ + System.out.println("error:"+e); + }finally{ + if(i>10){ + System.out.println(i); + } + System.out.println("finally"); + return 50; + } + } + + public static int m_2(){ + int i = 10; + try{ + System.out.println("start"); + return i += 10; + }catch(Exception e){ + System.out.println("error:"+e); + }finally{ + if(i>10){ + System.out.println(i); + } + System.out.println("finally"); + i = 50; + } + return i; + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/PrecisionDemo.java b/java-object/delombok/src-bak/src/main/java/com/hks/PrecisionDemo.java new file mode 100644 index 0000000..a8c0ed1 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/PrecisionDemo.java @@ -0,0 +1,19 @@ +package com.hks; + +public class PrecisionDemo { + + public static void main(String[] args){ + float calNum1; + double calNum2; + calNum1 = (float)(1.03-.42); + calNum2 = 1.03-.42; + System.out.println("calNum1="+ calNum1); + System.out.println("calNum2="+ calNum2); + System.out.println(1.03-.42); + calNum1 = (float)(1.00-9*.10); + calNum2 = 1.00-9*.10; + System.out.println("calNum1="+ calNum1); + System.out.println("calNum2="+ calNum2); + System.out.println(1.00-9*.10); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/PrimitiveTypeTest.java b/java-object/delombok/src-bak/src/main/java/com/hks/PrimitiveTypeTest.java new file mode 100644 index 0000000..b9dd30c --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/PrimitiveTypeTest.java @@ -0,0 +1,61 @@ +package com.hks; + +public class PrimitiveTypeTest { + + public static void main(String[] args) { + // byte + System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE); + System.out.println("包装类：java.lang.Byte"); + System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE); + System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE); + System.out.println(); + + // short + System.out.println("基本类型：short 二进制位数：" + Short.SIZE); + System.out.println("包装类：java.lang.Short"); + System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE); + System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE); + System.out.println(); + + // int + System.out.println("基本类型：int 二进制位数：" + Integer.SIZE); + System.out.println("包装类：java.lang.Integer"); + System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE); + System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE); + System.out.println(); + + // long + System.out.println("基本类型：long 二进制位数：" + Long.SIZE); + System.out.println("包装类：java.lang.Long"); + System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE); + System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE); + System.out.println(); + + // float + System.out.println("基本类型：float 二进制位数：" + Float.SIZE); + System.out.println("包装类：java.lang.Float"); + System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE); + System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE); + System.out.println(); + + // double + System.out.println("基本类型：double 二进制位数：" + Double.SIZE); + System.out.println("包装类：java.lang.Double"); + System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE); + System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE); + System.out.println(); + + // char + System.out.println("基本类型：char 二进制位数：" + Character.SIZE); + System.out.println("包装类：java.lang.Character"); + // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台 + System.out.println("最小值：Character.MIN_VALUE=" + + (int) Character.MIN_VALUE); + // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台 + System.out.println("最大值：Character.MAX_VALUE=" + + (int) Character.MAX_VALUE); + + //JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。 + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/QiangZhiZhuanHuan.java b/java-object/delombok/src-bak/src/main/java/com/hks/QiangZhiZhuanHuan.java new file mode 100644 index 0000000..30a5080 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/QiangZhiZhuanHuan.java @@ -0,0 +1,11 @@ +package com.hks; + +public class QiangZhiZhuanHuan{ + + public static void main(String[] args){ + int i1 = 123; + byte b = (byte)i1;//强制类型转换为byte + System.out.println("int强制类型转换为byte后的值等于"+b); + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/ZiDongLeiZhuan.java b/java-object/delombok/src-bak/src/main/java/com/hks/ZiDongLeiZhuan.java new file mode 100644 index 0000000..6d6dd7b --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/ZiDongLeiZhuan.java @@ -0,0 +1,14 @@ +package com.hks; + +public class ZiDongLeiZhuan{ + + public static void main(String[] args){ + char c1='a';//定义一个char类型 + int i1 = c1;//char自动类型转换为int + System.out.println("char自动类型转换为int后的值等于"+i1); + char c2 = 'A';//定义一个char类型 + int i2 = c2+1;//char 类型和 int 类型计算 + System.out.println("char类型和int计算后的值等于"+i2); + } + +} \ No newline at end of file diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/builder/BuilderTest.java b/java-object/delombok/src-bak/src/main/java/com/hks/builder/BuilderTest.java new file mode 100644 index 0000000..89619b7 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/builder/BuilderTest.java @@ -0,0 +1,16 @@ +package com.hks.builder; + +import static java.lang.System.out; +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + */ +public class BuilderTest { + + public static void main(String[] args) { + User.Builder builder = new User.Builder(); + User user = builder.setName("corn").setAge(100).setAddress("广州").build(); + out.print(user.toString()); + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/builder/User.java b/java-object/delombok/src-bak/src/main/java/com/hks/builder/User.java new file mode 100644 index 0000000..b88987d --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/builder/User.java @@ -0,0 +1,58 @@ +package com.hks.builder; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + *

+ * 通过静态内部类等方式实现的零件无序话构造： + */ +public class User { + + private String name; + private int age; + private String address; + + public String getName() { + return name; + } + + public int getAge() { + return age; + } + + public String getAddress() { + return address; + } + + @Override + public String toString() { + return "User{" + + "name='" + name + '\'' + + ", age=" + age + + ", address='" + address + '\'' + + '}'; + } + + public static class Builder { + private User user = new User(); + + public Builder setName(String name) { + user.name = name; + return this; + } + + public Builder setAge(int age){ + user.age = age; + return this; + } + + public Builder setAddress(String address){ + user.address =address; + return this; + } + + public User build(){ + return user; + } + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/cloneClass/Person.java b/java-object/delombok/src-bak/src/main/java/com/hks/cloneClass/Person.java new file mode 100644 index 0000000..d856f47 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/cloneClass/Person.java @@ -0,0 +1,39 @@ +package com.hks.cloneClass; + +public class Person implements Cloneable{ + + private Integer age; + + private String name; + + public Person(Integer age, String name) { + this.age = age; + this.name = name; + } + + public Integer getAge() { + return age; + } + + public void setAge(Integer age) { + this.age = age; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + @Override + public String toString() { + return super.toString(); + } + + @Override + protected Object clone() throws CloneNotSupportedException { + return super.clone(); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/cloneClass/RealCopy.java b/java-object/delombok/src-bak/src/main/java/com/hks/cloneClass/RealCopy.java new file mode 100644 index 0000000..fb1cf46 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/cloneClass/RealCopy.java @@ -0,0 +1,97 @@ +package com.hks.cloneClass; + +import org.junit.Test; + +/** + * 浅拷贝 + *

+ * 可见，二者的name属性依然是指向同一个对象。 + * 上面故意将age属性改为int基本类型，因为基本数据类型是不存在引用问题。 + * 这实际上就是典型的浅拷贝 + */ +public class RealCopy { + + @Test + public void copyRealObject() throws CloneNotSupportedException { + Person p = new Person(23, "zhang"); + Person p1 = (Person) p.clone(); + System.out.println(p); + System.out.println(p1); + System.out.println("------------------------------"); + System.out.println("pName：" + p.getName().hashCode()); + System.out.println("p1Name：" + p1.getName().hashCode()); + } + + /** + * 对Body对象来说，算是这算是深拷贝吗？ + * 其实应该算是深拷贝，因为对Body对象内所引用的其他对象（目前只有Head）都进行了拷贝， + * 也就是说两个独立的Body对象内的head引用已经指向了独立的两个Head对象 + *

+ * 但是，这对于两个Head对象来说，他们指向了同一个Face对象， + * 这就说明，两个Body对象还是有一定的联系，并没有完全的独立。这应该说是一种不彻底的深拷贝 + * + * 至于彻底深拷贝，几乎是不可能实现的，原因已经在上一节中进行了说明。 + * 深拷贝和彻底深拷贝，在创建不可变对象时，可能对程序有着微妙的影响， + * 可能会决定我们创建的不可变对象是不是真的不可变。clone的一个重要的应用也是用于不可变对象的创建。 + * @throws CloneNotSupportedException + */ + @Test + public void reallyCopy() throws CloneNotSupportedException { + + Body body = new Body(new Head(new Face())); + + Body body1 = (Body) body.clone(); + + System.out.println("body == body1 : " + (body == body1)); + + System.out.println("body.head == body1.head : " + (body.head == body1.head)); + + System.out.println("body.head.face == body1.head.face : " + (body.head.face == body1.head.face)); + + } + + static class Body implements Cloneable { + public Head head; + + public Body() { + } + + public Body(Head head) { + this.head = head; + } + + @Override + protected Object clone() throws CloneNotSupportedException { + Body newBody = (Body) super.clone(); + newBody.head = (Head) head.clone(); + return newBody; + } + + } + + static class Head implements Cloneable { + public Face face; + + public Head() { + } + + public Head(Face face) { + this.face = face; + } + + @Override + protected Object clone() throws CloneNotSupportedException { + Head head = (Head) super.clone(); + head.face = (Face) face.clone(); + return head; + } + } + + static class Face implements Cloneable{ + @Override + protected Object clone() throws CloneNotSupportedException { + return super.clone(); + } + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/cloneClass/ReferenceCopy.java b/java-object/delombok/src-bak/src/main/java/com/hks/cloneClass/ReferenceCopy.java new file mode 100644 index 0000000..3f8ceeb --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/cloneClass/ReferenceCopy.java @@ -0,0 +1,20 @@ +package com.hks.cloneClass; + +import org.junit.Test; + +/** + * 引用拷贝 + * + * 可以看到，打印的结果是一样的， + * 也就是说，二者的引用是同一个对象，并没有创建出一个新的对象 + */ +public class ReferenceCopy { + + @Test + public void copyReferenceObject(){ + Person p = new Person(23, "zhang"); + Person p1 = p; + System.out.println(p); + System.out.println(p1); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/AntStatus.java b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/AntStatus.java new file mode 100644 index 0000000..45e3984 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/AntStatus.java @@ -0,0 +1,11 @@ +package com.hks.enumClass; + +public enum AntStatus { + INITIALIZING, + COMPILING, + COPYING, + JARRING, + ZIPPING, + DONE, + ERROR +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/EnumClassTest.java b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/EnumClassTest.java new file mode 100644 index 0000000..d2b9c56 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/EnumClassTest.java @@ -0,0 +1,67 @@ +package com.hks.enumClass; + +import org.junit.Test; + +import java.io.IOException; +import java.io.PrintStream; +import java.util.EnumMap; + +public class EnumClassTest { + + public static void main(String args[]){ + // values() 的返回值是 Grade[] + for (Grade g : Grade.values()) { + System.out.println("Allowed value: '" + g + "'"); + } + } + + @Test + public void testSwitchStatement(PrintStream out) throws IOException { + Student student = new Student("kuangsheng","he"); + StringBuffer outputText = new StringBuffer(student.getFullName()); + switch (student.getGrade()) { + case A: + outputText.append(" excelled with a grade of A"); + break; + case B: // fall through to C + case C: + outputText.append(" passed with a grade of ") + .append(student.getGrade().toString()); + break; + case D: // fall through to F + case F: + outputText.append(" failed with a grade of ") + .append(student.getGrade().toString()); + break; + case INCOMPLETE: + outputText.append(" did not complete the class."); + break; + } + out.println(outputText.toString()); + } + + /** + * 该代码使用了泛型（generics）和新的 EnumMap 构造来建立新映射 + * @param out + * @throws IOException + */ + public void testEnumMap(PrintStream out) throws IOException { + // Create a map with the key and a String message + EnumMap antMessages = + new EnumMap(AntStatus.class); + // Initialize the map + antMessages.put(AntStatus.INITIALIZING, "Initializing Ant..."); + antMessages.put(AntStatus.COMPILING,"Compiling Java classes..."); + antMessages.put(AntStatus.COPYING,"Copying files..."); + antMessages.put(AntStatus.JARRING,"JARring up files..."); + antMessages.put(AntStatus.ZIPPING,"ZIPping up files..."); + antMessages.put(AntStatus.DONE, "Build complete."); + antMessages.put(AntStatus.ERROR,"Error occurred."); + // Iterate and print messages + for (AntStatus status : AntStatus.values() ) { + out.println("For status " + status + ", message is: " + + antMessages.get(status)); + } + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/EnumMapSample.java b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/EnumMapSample.java new file mode 100644 index 0000000..da08c60 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/EnumMapSample.java @@ -0,0 +1,22 @@ +package com.hks.enumClass; + +import java.util.*; +public class EnumMapSample { + enum Size { + Small, + Medium, + Large; + } + public static void main(String args[]) { + Map map = new EnumMap(Size.class); + map.put(Size.Small, 0.8); + map.put(Size.Medium, 1.0); + map.put(Size.Large, 1.2); + for (Map.Entry entry : map.entrySet()) { + helper(entry); + } + } + private static void helper(Map.Entry entry) { + System.out.println("Map entry: " + entry); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Grade.java b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Grade.java new file mode 100644 index 0000000..76d070d --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Grade.java @@ -0,0 +1,8 @@ +package com.hks.enumClass; + +/** + * 在这里，我使用了新的关键字 enum ，为 enum 提供了一个名称，并指定了允许的值。然后， Grade 就变成了一个 枚举类型 + */ +public enum Grade { + A, B, C, D, F, INCOMPLETE +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Sample.java b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Sample.java new file mode 100644 index 0000000..97d6c64 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Sample.java @@ -0,0 +1,18 @@ +package com.hks.enumClass; + +public class Sample { + enum Size { + Small(0.8), + Medium(1.0), + Large(1.2); + double pricingFactor; + Size(double p) { + pricingFactor = p; + } + } + public static void main(String args[]) { + Size s = Size.Large; + double d = s.pricingFactor; + System.out.println(s + " Size has pricing factor of " + d); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Sample2.java b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Sample2.java new file mode 100644 index 0000000..1c4e6de --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Sample2.java @@ -0,0 +1,21 @@ +package com.hks.enumClass; + +public class Sample2 { + enum Size { + Small(0.8), + Medium(1.0), + Large(1.2); + private double pricingFactor; + Size(double p) { + pricingFactor = p; + } + public double getPricingFactor() { + return pricingFactor; + } + } + public static void main(String args[]) { + Size s = Size.Large; + double d = s.getPricingFactor(); + System.out.println(s + " Size has pricing factor of " + d); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Sample3.java b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Sample3.java new file mode 100644 index 0000000..c3aeab3 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Sample3.java @@ -0,0 +1,32 @@ +package com.hks.enumClass; + +public class Sample3 { + enum Size { + Small { + public double getPricingFactor() { + return 0.8; + } + }, + Medium, + Large, + ExtraLarge { + public double getPricingFactor() { + return 1.2; + } + }, + ExtraExtraLarge { + public double getPricingFactor() { + return 1.2; + } + }; + public double getPricingFactor() { + return 1.0; + } + } + public static void main(String args[]) { + for (Size s : Size.values()) { + double d = s.getPricingFactor(); + System.out.println(s + " Size has pricing factor of " + d); + } + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Student.java b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Student.java new file mode 100644 index 0000000..9503608 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/enumClass/Student.java @@ -0,0 +1,50 @@ +package com.hks.enumClass; + +/** + * 在 assignGrade() 中是没有进行错误检测的代码，也没有考虑边界情况，请注意这是如何做到 + */ +public class Student { + + private String firstName; + + private String lastName; + + private Grade grade; + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + public Grade getGrade() { + return grade; + } + + public void setGrade(Grade grade) { + this.grade = grade; + } + + public Student(String firstName, String lastName) { + this.firstName = firstName; + this.lastName = lastName; + } + + public String getFullName(){ + return new StringBuffer(firstName) + .append(" ") + .append(lastName) + .toString(); + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/finalClass/FinalTest.java b/java-object/delombok/src-bak/src/main/java/com/hks/finalClass/FinalTest.java new file mode 100644 index 0000000..7329152 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/finalClass/FinalTest.java @@ -0,0 +1,44 @@ +package com.hks.finalClass; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + * + * true + * false + * + * 为什么第一个比较结果为true，而第二个比较结果为fasle。 + * + * 这里面就是final变量和普通变量的区别了，当final变量是基本数据类型以及String类型时， + * 如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。 + * + * 也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定。 + */ +public class FinalTest { + + public static void main(String[] args) { + String a = "hello2"; + final String b = "hello"; + String d = "hello"; + String c = b + 2; + String e = d + 2; + System.out.println((a == c)); + System.out.println((a == e)); + } + + // 不过要注意，只有在编译期间能确切知道final变量值的情况下， + // 编译器才会进行这样的优化， + // 比如下面的这段代码就不会进行优化： + public void test(String[] args) { + String a = "hello2"; + final String b = getHello(); + String c = b + 2; + System.out.println((a == c)); + + } + + public static String getHello() { + return "hello"; + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/hashcode/EqualsTest.java b/java-object/delombok/src-bak/src/main/java/com/hks/hashcode/EqualsTest.java new file mode 100644 index 0000000..181bc44 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/hashcode/EqualsTest.java @@ -0,0 +1,58 @@ +package com.hks.hashcode; + +import org.junit.Test; + +import java.util.LinkedList; +import java.util.List; + +/** + * 其实equals 比较的也是 两个 对象是否为同一对象，也就是比较的reference + */ +public class EqualsTest { + + Person person1 = new Person(); + Person person2 = person1; + + Person person3 = new Person(); + + @Test + public void addrTest() { + System.out.println(person1.equals(person2)); + person1.setAge(10); + System.out.println(person2.getAge()); + System.out.println(person1.equals(person2)); + System.out.println(person1.equals(person3)); + + System.out.println("============"); + List personList = new LinkedList<>(); + personList.add(person1); + Person person4 = person1; + person4.setAge(90); + personList.add(person4); + for (Person person : personList) { + System.out.println(person.toString() + person.getAge()); + } + ///equals没被重写 + /*public boolean equals(Object obj) { + return (this == obj); + }*/ + } + + @Test + public void intergerTest() { + Integer i1 = new Integer(1); + Integer i2 = new Integer(2); + Integer i3 = new Integer(1); + System.out.println(i1.equals(i2)); + System.out.println(i1.equals(i3)); + + ///equals被重写 + /*public boolean equals(Object obj) { + if (obj instanceof Integer) { + return value == ((Integer)obj).intValue(); + } + return false; + }*/ + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/hashcode/MapEqualstest.java b/java-object/delombok/src-bak/src/main/java/com/hks/hashcode/MapEqualstest.java new file mode 100644 index 0000000..f275eb2 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/hashcode/MapEqualstest.java @@ -0,0 +1,54 @@ +package com.hks.hashcode; + +import org.junit.Test; + +import java.util.HashMap; + +public class MapEqualstest { + + @Test + public void keyEqualsTest(){ + HashMap map = new HashMap(); + Person p1 = new Person(101); + Person p2 = new Person(102); + Person p3 = new Person(103); + map.put(p1, "tim"); + map.put(p2, "tony"); + map.put(p3, "Bi"); + System.out.println(map.get(new Person(101))); + + ///get的源码 + /*public V get(Object key) { + HashMap.Node e; + return (e = getNode(hash(key), key)) == null ? null : e.value; + } + +这个方法做了以下几件事情： +1. 将输入的对象的hashcode拿出来 + +2. 将输入对象的hashcode和所有的KeySet中的对象hashcode进行比较 + +3. 将输入对象和所有的KeySet中的对象使用equals方法进行比较 + final Node getNode(int hash, Object key) { + Node[] tab; Node first, e; int n; K k; + if ((tab = table) != null && (n = tab.length) > 0 && + (first = tab[(n - 1) & hash]) != null) { + if (first.hash == hash && // always check first node + ((k = first.key) == key || (key != null && key.equals(k)))) + return first; + if ((e = first.next) != null) { + if (first instanceof TreeNode) + return ((TreeNode)first).getTreeNode(hash, key); + do { + if (e.hash == hash && + ((k = e.key) == key || (key != null && key.equals(k)))) + return e; + } while ((e = e.next) != null); + } + } + return null; + }*/ + + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/hashcode/Person.java b/java-object/delombok/src-bak/src/main/java/com/hks/hashcode/Person.java new file mode 100644 index 0000000..b5b3573 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/hashcode/Person.java @@ -0,0 +1,47 @@ +package com.hks.hashcode; + +public class Person { + + private Integer age; + + private String name; + + @Override + public int hashCode () { + return this.age; + } + + @Override + public boolean equals (Object obj) { + return obj instanceof Person && + this.age == ((Person) obj).age; + } + + public Person() { + } + + public Person(Integer age) { + this.age = age; + } + + public Person(Integer age, String name) { + this.age = age; + this.name = name; + } + + public Integer getAge() { + return age; + } + + public void setAge(Integer age) { + this.age = age; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/serializable/DeserializeDemo.java b/java-object/delombok/src-bak/src/main/java/com/hks/serializable/DeserializeDemo.java new file mode 100644 index 0000000..9ea7f4e --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/serializable/DeserializeDemo.java @@ -0,0 +1,37 @@ +package com.hks.serializable; + +import java.io.*; +/** + * @Author: hekuangsheng + * @Date: 2018/10/15 + */ + +public class DeserializeDemo +{ + public static void main(String [] args) + { + Employee e = null; + try + { + FileInputStream fileIn = new FileInputStream("/Users/yiche/tmp/employee.ser"); + ObjectInputStream in = new ObjectInputStream(fileIn); + e = (Employee) in.readObject(); + in.close(); + fileIn.close(); + }catch(IOException i) + { + i.printStackTrace(); + return; + }catch(ClassNotFoundException c) + { + System.out.println("Employee class not found"); + c.printStackTrace(); + return; + } + System.out.println("Deserialized Employee..."); + System.out.println("Name: " + e.name); + System.out.println("Address: " + e.address); + System.out.println("SSN: " + e.SSN); + System.out.println("Number: " + e.number); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/serializable/Employee.java b/java-object/delombok/src-bak/src/main/java/com/hks/serializable/Employee.java new file mode 100644 index 0000000..4004788 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/serializable/Employee.java @@ -0,0 +1,18 @@ +package com.hks.serializable; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/15 + */ +public class Employee implements java.io.Serializable +{ + public String name; + public String address; + public transient int SSN; + public int number; + public void mailCheck() + { + System.out.println("Mailing a check to " + name + + " " + address); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/serializable/SerializeDemo.java b/java-object/delombok/src-bak/src/main/java/com/hks/serializable/SerializeDemo.java new file mode 100644 index 0000000..be0a661 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/serializable/SerializeDemo.java @@ -0,0 +1,34 @@ +package com.hks.serializable; + +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.ObjectOutputStream; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/15 + */ +public class SerializeDemo +{ + public static void main(String [] args) + { + Employee e = new Employee(); + e.name = "Reyan Ali"; + e.address = "Phokka Kuan, Ambehta Peer"; + e.SSN = 11122333; + e.number = 101; + try + { + FileOutputStream fileOut = + new FileOutputStream("/Users/yiche/tmp/employee.ser"); + ObjectOutputStream out = new ObjectOutputStream(fileOut); + out.writeObject(e); + out.close(); + fileOut.close(); + System.out.printf("Serialized data is saved in /Users/yiche/tmp/employee.ser"); + }catch(IOException i) + { + i.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/staticClass/Test.java b/java-object/delombok/src-bak/src/main/java/com/hks/staticClass/Test.java new file mode 100644 index 0000000..621cd82 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/staticClass/Test.java @@ -0,0 +1,91 @@ +package com.hks.staticClass; + +import java.math.BigDecimal; +import java.math.MathContext; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + *

+ * base static + * test static + * base constructor + * test constructor + *

+ * 在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前， + * 必须先加载Test类，而在加载Test类的时候发现Test类继承自Base类， + * 因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。 + *

+ * 在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块。 + *

+ * 在加载完所需的类之后，便开始执行main方法。 + * 在main方法中执行new Test()的时候会先调用父类的构造器，然后再调用自身的构造器。 + */ +public class Test extends Base { + + + static { + System.out.println("test static"); + } + + public Test() { + System.out.println("test constructor"); + } + + public static void main(String[] args) { + new Test(); + } + + @org.junit.Test + public void test() { + /** + * intVal BigInteger 这个BigDecimal的未缩放值 + * + * intCompact long 如果此BigDecimal的有效数的绝对值小于或等于{@code..MAX_VALUE}， + * 则该值可以紧凑地存储在该字段中并在计算中使用。 + * + * scale int BigDecimal的规模 + * + * precision int BigDecimal中的十进制数字的数目，或如果数字不知道（查找信息），则为0。 + * 如果非零值，则保证值正确。使用precision()方法获取和设置值，当然可能是0。这个字段是可变的，直到设置为非零为止。 + * + * stringCache string 用于存储规范字符串表示形式，如果计算的话。 + * + * + */ + BigDecimal bigDecimal = BigDecimal.valueOf(0.1); + System.out.print("bigDecimal->" + bigDecimal); + System.out.print("\n"); + BigDecimal bigDecimal1 = new BigDecimal(Double.toString(0.1)); + System.out.print("bigDecimal1->" + bigDecimal1); + System.out.print("\n"); + + BigDecimal bigDecimal2 = new BigDecimal(0.1, new MathContext(64)); + System.out.print("bigDecimal2->" + bigDecimal2); + System.out.print("\n"); + BigDecimal bigDecimal3 = bigDecimal.add(bigDecimal2); + System.out.print("bigDecimal3->" + bigDecimal3.toString()); + System.out.print("\n"); + + double d = 0.1; + System.out.print("double->" + (1-d)); + System.out.print("\n"); + + System.out.print("============="); + System.out.print(ThisClass.value); + System.out.print("-------------"); + ThisClass.value = 0; + System.out.print(ThisClass.value); + } +} + +class Base { + + static { + System.out.println("base static"); + } + + public Base() { + System.out.println("base constructor"); + } +} \ No newline at end of file diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/staticClass/Test2.java b/java-object/delombok/src-bak/src/main/java/com/hks/staticClass/Test2.java new file mode 100644 index 0000000..057e0f2 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/staticClass/Test2.java @@ -0,0 +1,60 @@ +package com.hks.staticClass; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + * + * test static + myclass static + person static + person Test + test constructor + person MyClass + myclass constructor + * + * 在加载完之后，就通过构造器来生成对象。 + * + * 而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()， + * 而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块， + * 接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了， + * + * 因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。 + */ +public class Test2 { + Person person = new Person("Test"); + + static { + System.out.println("test static"); + } + + public Test2() { + System.out.println("test constructor"); + } + + public static void main(String[] args) { + new MyClass(); + } +} + +class Person { + static { + System.out.println("person static"); + } + + public Person(String str) { + System.out.println("person " + str); + } +} + + +class MyClass extends Test { + Person person = new Person("MyClass"); + + static { + System.out.println("myclass static"); + } + + public MyClass() { + System.out.println("myclass constructor"); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/staticClass/ThisClass.java b/java-object/delombok/src-bak/src/main/java/com/hks/staticClass/ThisClass.java new file mode 100644 index 0000000..ac31530 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/staticClass/ThisClass.java @@ -0,0 +1,28 @@ +package com.hks.staticClass; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/23 + * + * 33 + * + * 这里面主要考察队this和static的理解。this代表什么？ + * this代表当前对象，那么通过new ThisClass()来调用printValue的话，当前对象就是通过new ThisClass()生成的对象。 + * 而static变量是被对象所享有的，因此在printValue中的this.value的值毫无疑问是33。 + * + * 静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够） + */ +public class ThisClass { + + static int value = 33; + + public static void main(String[] args) throws Exception { + new ThisClass().printValue(); + } + + private void printValue() { + int value = 3; + System.out.println(this.value); + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/valuePass/Person.java b/java-object/delombok/src-bak/src/main/java/com/hks/valuePass/Person.java new file mode 100644 index 0000000..882d1a6 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/valuePass/Person.java @@ -0,0 +1,29 @@ +package com.hks.valuePass; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/29 + */ +public class Person { + + private int age; + + private String name; + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/valuePass/RefrencePassTest.java b/java-object/delombok/src-bak/src/main/java/com/hks/valuePass/RefrencePassTest.java new file mode 100644 index 0000000..3715ef0 --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/valuePass/RefrencePassTest.java @@ -0,0 +1,32 @@ +package com.hks.valuePass; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/29 + *

+ * 引用传递： + * ”引用”也就是指向真实内容的地址值，在方法调用时， + * 实参的地址通过方法调用被传递给相应的形参，在方法体内， + * 形参和实参指向相同的内存地址，对形参的操作会影响的真实内容。 + */ +public class RefrencePassTest { + + public static void PersonCrossTest(Person person) { + System.out.println("传入的person的name：" + person.getName()); + person.setName("我是张小龙"); + + //加多此行代码 + ///无论是基本类型和是引用类型，在实参传入形参时，都是值传递，也就是说传递的都是一个副本，而不是内容本身。 + person = new Person(); + person.setName("啊哈"); + System.out.println("方法内重新赋值后的name：" + person.getName()); + } + + public static void main(String[] args) { + Person p = new Person(); + p.setName("我是马化腾"); + p.setAge(45); + PersonCrossTest(p); + System.out.println("方法执行后的name：" + p.getName()); + } +} diff --git a/java-object/delombok/src-bak/src/main/java/com/hks/valuePass/ValuePassTest.java b/java-object/delombok/src-bak/src/main/java/com/hks/valuePass/ValuePassTest.java new file mode 100644 index 0000000..772d42b --- /dev/null +++ b/java-object/delombok/src-bak/src/main/java/com/hks/valuePass/ValuePassTest.java @@ -0,0 +1,33 @@ +package com.hks.valuePass; + +/** + * @Author: hekuangsheng + * @Date: 2018/10/29 + *

+ * 值传递： + * 在方法被调用时，实参通过形参把它的内容副本传入方法内部， + * 此时形参接收到的内容是实参值的一个拷贝， + * 因此在方法内对形参的任何操作，都仅仅是对这个副本的操作，不影响原始值的内容。 + */ +public class ValuePassTest { + + public static void valueCrossTest(int age, float weight) { + System.out.println("传入的age：" + age); + System.out.println("传入的weight：" + weight); + + age = 33; + weight = 89.3f; + + System.out.println("方法内重新赋值后的age：" + age); + System.out.println("方法内重新赋值后的weight：" + weight); + } + + // 值传递传递的是真实内容的一个副本，对副本的操作不影响原内容，也就是形参怎么变化，不会影响实参对应的内容。 + public static void main(String[] args) { + int a = 25; + float w = 77.5f; + valueCrossTest(a, w); + System.out.println("方法执行后的age：" + a); + System.out.println("方法执行后的weight：" + w); + } +} diff --git a/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/UserService.java b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/UserService.java new file mode 100644 index 0000000..e92c68e --- /dev/null +++ b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/UserService.java @@ -0,0 +1,9 @@ +package com.hks.proxy; + +public interface UserService { + + String getName(int id); + + Integer getAge(int id); + +} diff --git a/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/UserServiceImpl.java b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/UserServiceImpl.java new file mode 100644 index 0000000..6af317d --- /dev/null +++ b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/UserServiceImpl.java @@ -0,0 +1,15 @@ +package com.hks.proxy; + +public class UserServiceImpl implements UserService { + + public String getName(int id) { + System.out.println("-------getName-------"); + return "Tom"; + } + + public Integer getAge(int id) { + System.out.println("-------getAge-------"); + return 10; + } + +} diff --git a/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/cglib/CglibProxyTest.java b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/cglib/CglibProxyTest.java new file mode 100644 index 0000000..3791ddf --- /dev/null +++ b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/cglib/CglibProxyTest.java @@ -0,0 +1,22 @@ +package com.hks.proxy.cglib; + +import com.hks.proxy.UserService; +import com.hks.proxy.UserServiceImpl; + +import net.sf.cglib.proxy.Enhancer; + +public class CglibProxyTest { + + public static void main(String[] args) { + MyMethodInterceptor myMethodInterceptor = new MyMethodInterceptor(); + + Enhancer enhancer = new Enhancer(); + enhancer.setSuperclass(UserServiceImpl.class); + enhancer.setCallback(myMethodInterceptor); + + UserService o = (UserService)enhancer.create(); + o.getName(1); + o.getAge(1); + } + +} diff --git a/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/cglib/MyMethodInterceptor.java b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/cglib/MyMethodInterceptor.java new file mode 100644 index 0000000..de91d27 --- /dev/null +++ b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/cglib/MyMethodInterceptor.java @@ -0,0 +1,18 @@ +package com.hks.proxy.cglib; + +import net.sf.cglib.proxy.MethodInterceptor; +import net.sf.cglib.proxy.MethodProxy; + +import java.lang.reflect.Method; + +public class MyMethodInterceptor implements MethodInterceptor { + + @Override + public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { + System.out.println("++++++before " + methodProxy.getSuperName() + "++++++"); + Object o1 = methodProxy.invokeSuper(o, args); + System.out.println("++++++after " + methodProxy.getSuperName() + "++++++"); + return o1; + } + +} diff --git a/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/jdk/JDKProxyTest.java b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/jdk/JDKProxyTest.java new file mode 100644 index 0000000..dde16c0 --- /dev/null +++ b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/jdk/JDKProxyTest.java @@ -0,0 +1,20 @@ +package com.hks.proxy.jdk; + +import com.hks.proxy.UserService; +import com.hks.proxy.UserServiceImpl; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Proxy; + +public class JDKProxyTest { + + public static void main(String[] args) { + UserService userService = new UserServiceImpl(); + InvocationHandler invocationHandler = new MyInvocationHandler(userService); + UserService userServiceProxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), + userService.getClass().getInterfaces(), invocationHandler); + System.out.println(userServiceProxy.getName(1)); + System.out.println(userServiceProxy.getAge(1)); + } + +} diff --git a/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/jdk/MyInvocationHandler.java b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/jdk/MyInvocationHandler.java new file mode 100644 index 0000000..c8c5f49 --- /dev/null +++ b/java-proxy/delombok/src-bak/src/main/java/com/hks/proxy/jdk/MyInvocationHandler.java @@ -0,0 +1,37 @@ +package com.hks.proxy.jdk; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; + +/** + * jdk动态代理是jdk原生就支持的一种代理方式， + * 它的实现原理，就是通过让target类和代理类实现同一接口，代理类持有target对象，来达到方法拦截的作用 + */ +public class MyInvocationHandler implements InvocationHandler { + + private Object target; + + MyInvocationHandler(){ + super(); + } + + MyInvocationHandler(Object target){ + super(); + this.target = target; + } + + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + if("getName".equals(method.getName())){ + System.out.println("++++++before " + method.getName() + "++++++"); + Object result = method.invoke(target,args); + System.out.println("++++++after " + method.getName() + "++++++"); + return result; + } + else { + Object result = method.invoke(target,args); + return result; + } + } + +} diff --git a/java-recall/delombok/src-bak/src/main/java/com/hks/recall/Solution.java b/java-recall/delombok/src-bak/src/main/java/com/hks/recall/Solution.java new file mode 100644 index 0000000..3294c84 --- /dev/null +++ b/java-recall/delombok/src-bak/src/main/java/com/hks/recall/Solution.java @@ -0,0 +1,46 @@ +package com.hks.recall; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * @Author: hekuangsheng + * @Date: 2018/11/27 + */ +public class Solution { + + public static void main(String[] args) { + Solution p = new Solution(); + System.out.println(p.Permutation("abc").toString()); + } + + public ArrayList Permutation(String str) { + List res = new ArrayList<>(); + if (str != null && str.length() > 0) { + PermutationHelper(str.toCharArray(), 0, res); + Collections.sort(res); + } + return (ArrayList) res; + } + + public void PermutationHelper(char[] cs, int i, List list) { + if (i == cs.length - 1) { + String val = String.valueOf(cs); + if (!list.contains(val)) + list.add(val); + } else { + for (int j = i; j < cs.length; j++) { + swap(cs, i, j); + PermutationHelper(cs, i + 1, list); + swap(cs, i, j); + } + } + } + + public void swap(char[] cs, int i, int j) { + char temp = cs[i]; + cs[i] = cs[j]; + cs[j] = temp; + } +} \ No newline at end of file diff --git a/java-sysEnv/delombok/src-bak/src/main/java/com/heks/jj/JavaSysEnvApplication.java b/java-sysEnv/delombok/src-bak/src/main/java/com/heks/jj/JavaSysEnvApplication.java new file mode 100644 index 0000000..4ebba55 --- /dev/null +++ b/java-sysEnv/delombok/src-bak/src/main/java/com/heks/jj/JavaSysEnvApplication.java @@ -0,0 +1,13 @@ +package com.heks.jj; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class JavaSysEnvApplication { + + public static void main(String[] args) { + SpringApplication.run(JavaSysEnvApplication.class, args); + } + +} diff --git a/java-sysEnv/delombok/src-bak/src/main/resources/application.properties b/java-sysEnv/delombok/src-bak/src/main/resources/application.properties new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/java-sysEnv/delombok/src-bak/src/main/resources/application.properties @@ -0,0 +1 @@ + diff --git a/java-sysEnv/delombok/src-bak/src/test/java/com/heks/jj/JavaSysEnvApplicationTests.java b/java-sysEnv/delombok/src-bak/src/test/java/com/heks/jj/JavaSysEnvApplicationTests.java new file mode 100644 index 0000000..a1b2577 --- /dev/null +++ b/java-sysEnv/delombok/src-bak/src/test/java/com/heks/jj/JavaSysEnvApplicationTests.java @@ -0,0 +1,57 @@ +package com.heks.jj; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.junit4.SpringRunner; + +import java.util.Properties; + +@RunWith(SpringRunner.class) +@SpringBootTest +public class JavaSysEnvApplicationTests { + + @Test + public void contextLoads() { + } + + @Test + public void test(){ + //获取所有的属性 + Properties properties = System.getProperties(); + //遍历所有的属性 + for (String key : properties.stringPropertyNames()) { + //输出对应的键和值 + System.out.println(key + "=" + properties.getProperty(key)); + } + + } + + @Test + public void testJDBC(){ + //获取所有的属性 + Properties properties = System.getProperties(); + //为了看看系统的属性有几个，加了一个计数器 + int count = 0; + //遍历所有的属性 + for (String key : properties.stringPropertyNames()) { + System.out.println(key + "=" + properties.getProperty(key)); + count++; + if (key.equalsIgnoreCase("jdbc.drivers")){ + System.out.println("YES"); + return ; + } + + } + System.out.println(count); + } + + + @Test + public void testGETSET(){ + System.setProperty("xueqiu.env", "production"); + System.out.println(System.getProperty("xueqiu.env")); + String env = System.getProperty("xueqiu.env", "sep"); + System.out.println(env); + } +} diff --git a/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/PoolSizeCalculator.java b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/PoolSizeCalculator.java new file mode 100644 index 0000000..9c7349f --- /dev/null +++ b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/PoolSizeCalculator.java @@ -0,0 +1,208 @@ +/* + * 文件名：PoolSizeCalculator.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/22 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.threadpool; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.util.Timer; +import java.util.TimerTask; +import java.util.concurrent.BlockingQueue; + +/** + * A class that calculates the optimal thread pool boundaries. It takes the + * desired target utilization and the desired work queue memory consumption as + * input and retuns thread count and work queue capacity. + * + * @author Niklas Schlimm + */ +public abstract class PoolSizeCalculator { + + /** + * The sample queue size to calculate the size of a single {@link Runnable} + * element. + */ + private static final int SAMPLE_QUEUE_SIZE = 1000; + + /** + * Accuracy of test run. It must finish within 20ms of the testTime + * otherwise we retry the test. This could be configurable. + */ + private static final int EPSYLON = 20; + + /** + * Control variable for the CPU time investigation. + */ + private volatile boolean expired; + + /** + * Time (millis) of the test run in the CPU time calculation. + */ + private final long elapsed = 3000; + + /** + * Calculates the boundaries of a thread pool for a given {@link Runnable}. + * + * @param targetUtilization the desired utilization of the CPUs (0 <= targetUtilization <= 1) + * @param targetQueueSizeBytes the desired maximum work queue size of the thread pool (bytes) + */ + void calculateBoundaries(BigDecimal targetUtilization, BigDecimal targetQueueSizeBytes) { + calculateOptimalCapacity(targetQueueSizeBytes); + Runnable task = createTask(); + start(task); + start(task); // warm up phase + long cputime = getCurrentThreadCPUTime(); + start(task); // test interval + cputime = getCurrentThreadCPUTime() - cputime; + long waitTime = (elapsed * 1000000) - cputime; + calculateOptimalThreadCount(cputime, waitTime, targetUtilization); + } + + private void calculateOptimalCapacity(BigDecimal targetQueueSizeBytes) { + long mem = calculateMemoryUsage(); + BigDecimal queueCapacity = targetQueueSizeBytes.divide(new BigDecimal(mem), + RoundingMode.HALF_UP); + System.out.println("Target queue memory usage (bytes): " + + targetQueueSizeBytes); + System.out.println("createTask() produced " + createTask().getClass().getName() + " which took " + mem + " bytes in a queue"); + System.out.println("Formula: " + targetQueueSizeBytes + " / " + mem); + System.out.println("* Recommended queue capacity (bytes): " + queueCapacity); + } + + /** + * Brian Goetz' optimal thread count formula, see 'Java Concurrency in + * * Practice' (chapter 8.2) * + * * @param cpu + * * cpu time consumed by considered task + * * @param wait + * * wait time of considered task + * * @param targetUtilization + * * target utilization of the system + */ + private void calculateOptimalThreadCount(long cpu, long wait, + BigDecimal targetUtilization) { + BigDecimal computeTime = new BigDecimal(cpu); + BigDecimal waitTime = new BigDecimal(wait); + BigDecimal numberOfCPU = new BigDecimal(Runtime.getRuntime() + .availableProcessors()); + BigDecimal optimalthreadcount = numberOfCPU.multiply(targetUtilization) + .multiply(new BigDecimal(1).add(waitTime.divide(computeTime, + RoundingMode.HALF_UP))); + System.out.println("Number of CPU: " + numberOfCPU); + System.out.println("Target utilization: " + targetUtilization); + System.out.println("Elapsed time (nanos): " + (elapsed * 1000000)); + System.out.println("Compute time (nanos): " + cpu); + System.out.println("Wait time (nanos): " + wait); + System.out.println("Formula: " + numberOfCPU + " * " + + targetUtilization + " * (1 + " + waitTime + " / " + + computeTime + ")"); + System.out.println("* Optimal thread count: " + optimalthreadcount); + } + + /** + * * Runs the {@link Runnable} over a period defined in {@link #elapsed}. + * * Based on Heinz Kabbutz' ideas + * * (http://www.javaspecialists.eu/archive/Issue124.html). + * * + * * @param task + * * the runnable under investigation + */ + public void start(Runnable task) { + long start = 0; + int runs = 0; + do { + if (++runs > 10) { + throw new IllegalStateException("Test not accurate"); + } + expired = false; + start = System.currentTimeMillis(); + Timer timer = new Timer(); + timer.schedule(new TimerTask() { + public void run() { + expired = true; + } + }, elapsed); + while (!expired) { + task.run(); + } + start = System.currentTimeMillis() - start; + timer.cancel(); + } while (Math.abs(start - elapsed) > EPSYLON); + collectGarbage(3); + } + + private void collectGarbage(int times) { + for (int i = 0; i < times; i++) { + System.gc(); + try { + Thread.sleep(10); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + break; + } + } + } + + /** + * Calculates the memory usage of a single element in a work queue. Based on + * Heinz Kabbutz' ideas + * (http://www.javaspecialists.eu/archive/Issue029.html). + * + * @return memory usage of a single {@link Runnable} element in the thread + * pools work queue + */ + private long calculateMemoryUsage() { + BlockingQueue queue = createWorkQueue(SAMPLE_QUEUE_SIZE); + for (int i = 0; i < SAMPLE_QUEUE_SIZE; i++) { + queue.add(createTask()); + } + long mem0 = Runtime.getRuntime().totalMemory() - + Runtime.getRuntime().freeMemory(); + long mem1 = Runtime.getRuntime().totalMemory() - + Runtime.getRuntime().freeMemory(); + queue = null; + collectGarbage(15); + mem0 = Runtime.getRuntime().totalMemory() + - Runtime.getRuntime().freeMemory(); + queue = createWorkQueue(SAMPLE_QUEUE_SIZE); + for (int i = 0; i < SAMPLE_QUEUE_SIZE; i++) { + queue.add(createTask()); + } + collectGarbage(15); + mem1 = Runtime.getRuntime().totalMemory() + - Runtime.getRuntime().freeMemory(); + return (mem1 - mem0) / SAMPLE_QUEUE_SIZE; + } + + /** + * Create your runnable task here. + * + * @return an instance of your runnable task under investigation + */ + protected abstract Runnable createTask(); + + /** + * Return an instance of the queue used in the thread pool. + * + * @return queue instance + */ + protected abstract BlockingQueue createWorkQueue(int capacity); + + /** + * Calculate current cpu time. Various frameworks may be used here, + * depending on the operating system in use. (e.g. + * http://www.hyperic.com/products/sigar). The more accurate the CPU time + * measurement, the more accurate the results for thread count boundaries. + * + * @return current cpu time of current thread + */ + protected abstract long getCurrentThreadCPUTime(); + +} diff --git a/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/SimplePoolSizeCaculator.java b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/SimplePoolSizeCaculator.java new file mode 100644 index 0000000..7efa17a --- /dev/null +++ b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/SimplePoolSizeCaculator.java @@ -0,0 +1,92 @@ +/* + * 文件名：SimplePoolSizeCaculator.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/22 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.threadpool; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.lang.management.ManagementFactory; +import java.math.BigDecimal; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; + +public class SimplePoolSizeCaculator extends PoolSizeCalculator { + + @Override + protected Runnable createTask() { + return new AsyncIOTask(); + } + + @Override + protected BlockingQueue createWorkQueue(int capacity) { + return new LinkedBlockingQueue(capacity); + } + + @Override + protected long getCurrentThreadCPUTime() { + //the total CPU time for the current thread in nanoseconds + return ManagementFactory.getThreadMXBean().getCurrentThreadCpuTime(); + } + + public static void main(String[] args) { + PoolSizeCalculator poolSizeCalculator = new SimplePoolSizeCaculator(); + poolSizeCalculator.calculateBoundaries(new BigDecimal(1.0), new BigDecimal(100000)); + } + +} + +/** + * 自定义的异步IO任务 + * @author Will + * + */ +class AsyncIOTask implements Runnable { + + @Override + public void run() { + HttpURLConnection connection = null; + BufferedReader reader = null; + try { + URL url = new URL("http://baidu.com"); + + connection = (HttpURLConnection) url.openConnection(); + connection.connect(); + reader = new BufferedReader(new InputStreamReader( + connection.getInputStream())); + + String line; + StringBuilder stringBuilder; + while ((line = reader.readLine()) != null) { + stringBuilder = new StringBuilder(); + stringBuilder.append(line); + } + } + + catch (IOException e) { + + } finally { + if(reader != null) { + try { + reader.close(); + } + catch(Exception e) { + + } + } + if (connection != null) + connection.disconnect(); + } + + } + +} diff --git a/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/TestThreadPool.java b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/TestThreadPool.java new file mode 100644 index 0000000..0e30905 --- /dev/null +++ b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/TestThreadPool.java @@ -0,0 +1,33 @@ +/* + * 文件名：TestThreadPool.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/22 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.threadpool; + +//测试线程池 +public class TestThreadPool { + public static void main(String[] args) { + // 创建3个线程的线程池 + ThreadPool t = ThreadPool.getThreadPool(3); + t.execute(new Runnable[] { new Task(), new Task(), new Task() }); + t.execute(new Runnable[] { new Task(), new Task(), new Task() }); + System.out.println(t); + t.destroy();// 所有线程都执行完成才destory + System.out.println(t); + } + + // 任务类 + static class Task implements Runnable { + private static volatile int i = 1; + + public void run() {// 执行任务 + System.out.println("任务 " + (i++) + " 完成"); + } + } +} diff --git a/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/ThreadPool.java b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/ThreadPool.java new file mode 100644 index 0000000..86e493c --- /dev/null +++ b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/ThreadPool.java @@ -0,0 +1,164 @@ +/* + * 文件名：ThreadPool.java + * 版权：Copyright by www.yiche.com + * 描述： + * 修改人：hekuangsheng + * 修改时间：2019/3/22 + * 跟踪单号： + * 修改单号： + * 修改内容： + */ +package com.hks.threadpool; + +import java.util.LinkedList; +import java.util.List; + +/** + * 线程池类，线程管理器：创建线程，执行任务，销毁线程，获取线程基本信息 + */ +public final class ThreadPool { + // 线程池中默认线程的个数为5 + private static int worker_num = 5; + // 工作线程 + private WorkThread[] workThrads; + // 未处理的任务 + private static volatile int finished_task = 0; + // 任务队列，作为一个缓冲,List线程不安全 + private List taskQueue = new LinkedList(); + private static ThreadPool threadPool; + + // 创建具有默认线程个数的线程池 + private ThreadPool() { + this(5); + } + + // 创建线程池,worker_num为线程池中工作线程的个数 + private ThreadPool(int worker_num) { + ThreadPool.worker_num = worker_num; + workThrads = new WorkThread[worker_num]; + for (int i = 0; i < worker_num; i++) { + workThrads[i] = new WorkThread(); + workThrads[i].start();// 开启线程池中的线程 + } + } + + // 单态模式，获得一个默认线程个数的线程池 + public static ThreadPool getThreadPool() { + return getThreadPool(ThreadPool.worker_num); + } + + // 单态模式，获得一个指定线程个数的线程池,worker_num(>0)为线程池中工作线程的个数 + // worker_num<=0创建默认的工作线程个数 + public static ThreadPool getThreadPool(int worker_num1) { + if (worker_num1 <= 0) + worker_num1 = ThreadPool.worker_num; + if (threadPool == null) + threadPool = new ThreadPool(worker_num1); + return threadPool; + } + + // 执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定 + public void execute(Runnable task) { + synchronized (taskQueue) { + taskQueue.add(task); + taskQueue.notify(); + } + } + + // 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定 + public void execute(Runnable[] task) { + synchronized (taskQueue) { + for (Runnable t : task) + taskQueue.add(t); + taskQueue.notify(); + } + } + + // 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定 + public void execute(List task) { + synchronized (taskQueue) { + for (Runnable t : task) + taskQueue.add(t); + taskQueue.notify(); + } + } + + // 销毁线程池,该方法保证在所有任务都完成的情况下才销毁所有线程，否则等待任务完成才销毁 + public void destroy() { + while (!taskQueue.isEmpty()) {// 如果还有任务没执行完成，就先睡会吧 + try { + Thread.sleep(10); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + // 工作线程停止工作，且置为null + for (int i = 0; i < worker_num; i++) { + workThrads[i].stopWorker(); + workThrads[i] = null; + } + threadPool=null; + taskQueue.clear();// 清空任务队列 + } + + // 返回工作线程的个数 + public int getWorkThreadNumber() { + return worker_num; + } + + // 返回已完成任务的个数,这里的已完成是只出了任务队列的任务个数，可能该任务并没有实际执行完成 + public int getFinishedTasknumber() { + return finished_task; + } + + // 返回任务队列的长度，即还没处理的任务个数 + public int getWaitTasknumber() { + return taskQueue.size(); + } + + // 覆盖toString方法，返回线程池信息：工作线程个数和已完成任务个数 + @Override + public String toString() { + return "WorkThread number:" + worker_num + " finished task number:" + + finished_task + " wait task number:" + getWaitTasknumber(); + } + + /** + * 内部类，工作线程 + */ + private class WorkThread extends Thread { + // 该工作线程是否有效，用于结束该工作线程 + private boolean isRunning = true; + + /* + * 关键所在啊，如果任务队列不空，则取出任务执行，若任务队列空，则等待 + */ + @Override + public void run() { + Runnable r = null; + while (isRunning) {// 注意，若线程无效则自然结束run方法，该线程就没用了 + synchronized (taskQueue) { + while (isRunning && taskQueue.isEmpty()) {// 队列为空 + try { + taskQueue.wait(20); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + if (!taskQueue.isEmpty()) + r = taskQueue.remove(0);// 取出任务 + } + if (r != null) { + r.run();// 执行任务 + } + finished_task++; + r = null; + } + } + + // 停止工作，让该线程自然执行完run方法，自然结束 + public void stopWorker() { + isRunning = false; + } + } +} diff --git a/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/readme.md b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/readme.md new file mode 100644 index 0000000..087f88a --- /dev/null +++ b/java-thread/delombok/src-bak/src/main/java/com/hks/threadpool/readme.md @@ -0,0 +1,120 @@ +# 合理估算java的线程池大小及队列数 +## 原理分析 +>原文：http://ifeve.com/how-to-calculate-threadpool-size/ + +先来一个天真的估算方法：假设要求一个系统的TPS（Transaction Per Second或者Task Per Second）至少为20，然后假设每个Transaction由一个线程完成，继续假设平均每个线程处理一个Transaction的时间为4s。那么问题转化为： + +如何设计线程池大小，使得可以在1s内处理完20个Transaction？ + +计算过程很简单，每个线程的处理能力为0.25TPS，那么要达到20TPS，显然需要20/0.25=80个线程。 + +很显然这个估算方法很天真，因为它没有考虑到CPU数目。一般服务器的CPU核数为16或者32，如果有80个线程，那么肯定会带来太多不必要的线程上下文切换开销。 + +再来第二种简单的但不知是否可行的方法（N为CPU总核数）： + +- 如果是CPU密集型应用，则线程池大小设置为N+1； +- 如果是IO密集型应用，则线程池大小设置为2N+1； + +如果一台服务器上只部署这一个应用并且只有这一个线程池，那么这种估算或许合理，具体还需自行测试验证。 + +第三种方法是在服务器性能IO优化中发现的一个估算公式： + +>最佳线程数目 = （（线程等待时间 + 线程CPU时间）/ 线程CPU时间 ）* CPU数目 + +比如平均每个线程CPU运行时间为0.5s，而线程等待时间（非CPU运行时间，比如IO）为1.5s，CPU核心数为8，那么根据上面这个公式估算得到：((0.5+1.5)/0.5)*8=32。这个公式进一步转化为： + +>最佳线程数目 = （线程等待时间与线程CPU时间之比 + 1）* CPU数目 + +可以得出一个结论： + +- 线程CPU时间所占比例越高，需要越少线程。 +- 线程等待时间所占比例越高，需要越多线程。 + +上一种估算方法也和这个结论相合。 + +一个系统最快的部分是CPU，所以决定一个系统吞吐量上限的是CPU。增强CPU处理能力，可以提高系统吞吐量上限。但根据短板效应，真实的系统吞吐量并不能单纯根据CPU来计算。那要提高系统吞吐量，就需要从“系统短板”（比如网络延迟、IO）着手： + +- 尽量提高短板操作的并行化比率，比如多线程下载技术 +- 增强短板能力，比如用NIO替代IO + +第一条可以联系到Amdahl定律，这条定律定义了串行系统并行化后的加速比计算公式： + +>加速比=优化前系统耗时 / 优化后系统耗时 + +加速比越大，表明系统并行化的优化效果越好。 + +Addahl定律还给出了系统并行度、CPU数目和加速比的关系： + +加速比为Speedup，系统串行化比率（指串行执行代码所占比率）为F，CPU数目为N： + +>Speedup <= 1 / (F + (1-F)/N) + +当N足够大时，串行化比率F越小，加速比Speedup越大。 + +是否使用线程池就一定比使用单线程高效呢？ + +答案是否定的，比如Redis就是单线程的，但它却非常高效，基本操作都能达到十万量级/s。 + +从线程这个角度来看，部分原因在于多线程带来线程上下文切换开销，单线程就没有这种开销。 + +当然“Redis很快”更本质的原因在于：Redis基本都是内存操作，这种情况下单线程可以很高效地利用CPU。而多线程适用场景一般是：存在相当比例的IO和网络操作。 + +**所以即使有上面的估算方法，也许看似合理，但实际上也未必合理，都需要结合系统真实情况（比如是IO密集型或者是CPU密集型或者是纯内存操作）和硬件环境（CPU、内存、硬盘读写速度、网络状况等）来不断尝试达到一个符合实际的合理估算值。** + +## 源码分析 +### `PoolSizeCalculator`类 +#### `calculateBoundaries`方法 +入口类，计算线程池大小和队列数。 + +接收两个参数，CPU负载和队列总内存的大小（bytes） +#### `calculateMemoryUsage`方法 +计算单个任务的内存大小，计算方法： +1. 手动GC +2. 计算可用内存大小m0 +3. 创建一个队列，并往里面放1000个任务 +4. 再次GC +5. 计算可用内存大小m1 +6. `(m1 - m0) / 1000`即每个任务的大小 +>参考： +#### `calculateOptimalCapacity`方法 +计算队列数，计算公式：**队列总内存**/**单个任务的内存**。 + +接收一个参数：队列总内存的大小。 + +#### `start`方法 +计算*执行3秒的任务*所消耗CPU的实际使用时间。 +>参考： +#### `calculateOptimalThreadCount`方法 +计算线程池大小。 +计算公式：CPU核数 * （1 + 线程等待时间/线程CPU时间） +#### `collectGarbage`方法 +循环手动GC +### `SimplePoolSizeCaculator`类 +`PoolSizeCalculator`类的一个实现，计算*CPU负载1*，*队列总内存的大小为100k左右*的*IO密集型*的线程池大小和队列数 +#### `AsyncIOTask`类 +IO密集型的一个例子 + +## 使用方法 +```bash +# 下载 +git clone https://github.com/sunshanpeng/dark_magic.git +# 编译 +cd dark_magic && mvn package +# 执行 +java -jar target/dark_magic-1.0-SNAPSHOT.jar +``` +控制台打印示例 +```$xslt +Target queue memory usage (bytes): 100000 +createTask() produced threadpool.AsyncIOTask which took 40 bytes in a queue +Formula: 100000 / 40 +* Recommended queue capacity (bytes): 2500 +Number of CPU: 4 +Target utilization: 1 +Elapsed time (nanos): 3000000000 +Compute time (nanos): 125000000 +Wait time (nanos): 2875000000 +Formula: 4 * 1 * (1 + 2875000000 / 125000000) +* Optimal thread count: 96 +``` +> 如果不修改队列内存大小和任务，队列数可能都是2500 \ No newline at end of file