diff --git a/algorithms/pom.xml b/algorithms/pom.xml
new file mode 100644
index 0000000..31df642
--- /dev/null
+++ b/algorithms/pom.xml
@@ -0,0 +1,78 @@
+
+
+
+
+ java-learning
+ com.brianway.learning.java
+ 1.0-SNAPSHOT
+
+ 4.0.0
+
+ algorithms
+
+ algorithms
+
+ http://www.example.com
+
+
+ UTF-8
+ 1.7
+ 1.7
+
+
+
+
+ junit
+ junit
+ 4.11
+ test
+
+
+
+
+
+
+
+ maven-clean-plugin
+ 3.0.0
+
+
+
+ maven-resources-plugin
+ 3.0.2
+
+
+ maven-compiler-plugin
+ 3.7.0
+
+
+ maven-surefire-plugin
+ 2.20.1
+
+
+ maven-jar-plugin
+ 3.0.2
+
+
+ maven-install-plugin
+ 2.5.2
+
+
+ maven-deploy-plugin
+ 2.8.2
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+ 1.8
+ 1.8
+
+
+
+
+
diff --git a/algorithms/src/main/java/com/brianway/learning/algorithms/DistinctSubstring.java b/algorithms/src/main/java/com/brianway/learning/algorithms/DistinctSubstring.java
new file mode 100644
index 0000000..6e4cce8
--- /dev/null
+++ b/algorithms/src/main/java/com/brianway/learning/algorithms/DistinctSubstring.java
@@ -0,0 +1,48 @@
+package com.brianway.learning.algorithms;
+
+/**
+ * Created by brian on 16/11/9.
+ *
+ * 对于一个字符串,请设计一个高效算法，找到字符串的最长无重复字符的子串长度。
+ * 给定一个字符串A及它的长度n，请返回它的最长无重复字符子串长度。
+ * 保证A中字符全部为小写英文字符，且长度小于等于500。
+ *
+ * 测试样例：
+ * "aabcb",5
+ * 返回：3
+ */
+public class DistinctSubstring {
+ public int longestSubstring(String A, int n) {
+ if (A == null || n == 0) {
+ return 0;
+ }
+ char[] s = A.toCharArray();
+ int[] map = new int[256];
+ for (int i = 0; i < 256; i++) {
+ map[i] = -1;
+ }
+ System.err.println(map['a']);
+
+ int maxLen = 0;
+ int pre = -1;
+ int cur = 0;
+ for (int i = 0; i < n; i++) {
+ pre = Math.max(pre, map[s[i]]);
+ cur = i - pre;
+ System.out.println(s[i]+"("+i+") pre:"+ pre + " cur:"+cur);
+ System.err.println(map['a']);
+ maxLen = Math.max(cur, maxLen);
+ map[s[i]] = i;
+ }
+ return maxLen;
+ }
+
+ public static void main(String[] args) {
+ DistinctSubstring d = new DistinctSubstring();
+ System.out.println(d.longestSubstring("aabcba", 6));
+// System.out.println(d.longestSubstring("bacdbad",7));
+// System.out.println(d.longestSubstring("adsaasdfghjhgfdsa",
+// "adsaasdfghjhgfdsa".length()));
+ }
+
+}
\ No newline at end of file
diff --git a/algorithms/src/test/java/com/brianway/learning/java/AppTest.java b/algorithms/src/test/java/com/brianway/learning/java/AppTest.java
new file mode 100644
index 0000000..6a98f81
--- /dev/null
+++ b/algorithms/src/test/java/com/brianway/learning/java/AppTest.java
@@ -0,0 +1,25 @@
+package com.brianway.learning.java;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Predicate;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest
+{
+ /**
+ * Rigorous Test :-)
+ */
+ @Test
+ public void shouldAnswerWithTrue() {
+ assertTrue( true );
+ }
+
+}
diff --git a/java-base/pom.xml b/java-base/pom.xml
index c6536e9..5c86346 100644
--- a/java-base/pom.xml
+++ b/java-base/pom.xml
@@ -10,5 +10,13 @@
4.0.0
java-base
+
+
+ junit
+ junit
+ 4.12
+
+
+
\ No newline at end of file
diff --git a/java-base/src/main/java/com/brianway/learning/java/base/constructor/FatherClass.java b/java-base/src/main/java/com/brianway/learning/java/base/constructor/FatherClass.java
index 4ccca61..508984e 100644
--- a/java-base/src/main/java/com/brianway/learning/java/base/constructor/FatherClass.java
+++ b/java-base/src/main/java/com/brianway/learning/java/base/constructor/FatherClass.java
@@ -7,6 +7,7 @@ public class FatherClass {
protected static int count = 10;
private String name;
+ static String data = new String("静态变量初始化+++++++++++++++");
static {
System.out.println("父类的静态属性count初始化:" + count);
}
diff --git a/java-base/src/main/java/com/brianway/learning/java/base/constructor/InitialOrderWithExtend.java b/java-base/src/main/java/com/brianway/learning/java/base/constructor/InitialOrderWithExtend.java
new file mode 100644
index 0000000..b8bd706
--- /dev/null
+++ b/java-base/src/main/java/com/brianway/learning/java/base/constructor/InitialOrderWithExtend.java
@@ -0,0 +1,93 @@
+package com.brianway.learning.java.base.constructor;
+/*
+* 执行顺序：
+* 1. 父类 >子类
+* 2. 同类间: 同优先级按代码先后顺序;
+* 静态块, 静态类变量, 最高优先级
+* 普通块和普通成员, 次优先级
+* 构造函数 次次优先级
+* 对象方法 最低优先级
+* 3.子类初始化时，会首先调用父类的无参构造函数(无论是否有super())，然后子类的构造函数
+*/
+public class InitialOrderWithExtend {
+ public static void main(String[] args) {
+// Father father = new Son();
+ Father father = new Son(1000000);
+
+ }
+}
+
+class Father {
+ {
+ System.out.println("父类 非静态块 1 执行");
+ }
+ static {
+ System.out.println("父类 static块 1 执行");
+ }
+ static Sample staticSam1 = new Sample("父类 静态成员 staticSam1 初始化");
+ Sample sam1 = new Sample("父类 普通成员 sam1 初始化");
+ static Sample staticSam2 = new Sample("父类 静态成员 staticSam2 初始化");
+ static {
+ System.out.println("父类 static块 2 执行");
+ }
+
+ Father() {
+ System.out.println("父类 默认构造函数被调用");
+ }
+ {
+ System.out.println("父类 普通块被调用");
+ }
+
+ Sample sam2 = new Sample("父类 普通成员 sam2 初始化");
+
+ {
+ System.out.println("父类 非静态块 2 执行");
+ }
+
+}
+
+class Son extends Father {
+ {
+ System.out.println("子类 非静态块 1 执行");
+ }
+ private int number=100;
+ static Sample staticSamSub1 = new Sample("子类 静态成员 staticSamSub1 初始化");
+
+ Son() {
+ System.out.println("子类无参数构造函数"+number);
+ System.out.println("子类 默认构造函数被调用");
+ }
+
+ public Son(int number) {
+ System.out.println("子类有参数构造函数"+number); //此方法的number值是在构造函数初始化以后执行的
+ this.number = number;
+ System.out.println("子类有参数构造函数"+number);
+
+ }
+ Sample sam1 = new Sample("子类 普通成员 sam1 初始化");
+ static Sample staticSamSub2 = new Sample("子类 静态成员 staticSamSub2 初始化");
+
+ static {
+ System.out.println("子类 static块1 执行");
+ }
+
+ Sample sam2 = new Sample("子类 普通成员 sam2 初始化");
+
+ {
+ System.out.println("子类 非静态块 2 执行");
+ }
+
+ static {
+ System.out.println("子类 static块2 执行");
+ }
+}
+
+class Sample {
+ Sample(String s) {
+ System.out.println(s);
+ }
+
+ Sample() {
+ System.out.println("Sample默认构造函数被调用");
+ }
+}
diff --git a/java-base/src/main/java/com/brianway/learning/java/base/constructor/InitialOrderWithoutExtend.java b/java-base/src/main/java/com/brianway/learning/java/base/constructor/InitialOrderWithoutExtend.java
new file mode 100644
index 0000000..3cfeea7
--- /dev/null
+++ b/java-base/src/main/java/com/brianway/learning/java/base/constructor/InitialOrderWithoutExtend.java
@@ -0,0 +1,93 @@
+package com.brianway.learning.java.base.constructor;
+
+
+/*
+*
+* 由输出结果可知，执行顺序为：
+* static静态代码块和静态成员
+* 普通成员，普通块
+* 构造函数执行
+* 当具有多个静态成员和静态代码块或者多个普通成员时，初始化顺序和成员在程序中申明的顺序一致。
+*
+* 注意到在该程序的静态代码块中，修改了静态成员sam的引用。
+* main()方法中创建了2个主类对象，但是由输出结果可知，静态成员和静态代码块只进行了一次初始化，并且新建的2个主类对象的静态成员sam.s是相同的。
+* 由此可知，类的静态成员和静态代码块在类加载中是最先进行初始化的，并且只进行一次。
+* 该类的多个实例共享静态成员，静态成员的引用指向程序最后所赋予的引用。
+*/
+
+public class InitialOrderWithoutExtend {
+ static SampleClass sam = new SampleClass("静态成员sam初始化");
+ SampleClass sam1 = new SampleClass("普通成员sam1初始化");
+ static {
+ System.out.println("static块执行");
+ if (sam == null)
+ System.out.println("sam is null");
+ sam = new SampleClass("静态块内初始化sam成员变量");
+ }
+ {
+ System.out.println("普通块执行");
+ }
+
+ SampleClass sam2 = new SampleClass("普通成员sam2初始化");
+
+ InitialOrderWithoutExtend() {
+ System.out.println("InitialOrderWithoutExtend默认构造函数被调用");
+ }
+
+ public static void main(String[] args) {
+ // 创建第1个主类对象
+ System.out.println("第1个主类对象：");
+ InitialOrderWithoutExtend ts = new InitialOrderWithoutExtend();
+
+ // 创建第2个主类对象
+ System.out.println("第2个主类对象：");
+ InitialOrderWithoutExtend ts2 = new InitialOrderWithoutExtend();
+
+ // 查看两个主类对象的静态成员：
+ System.out.println("2个主类对象的静态对象：");
+ System.out.println("第1个主类对象, 静态成员sam.s: " + ts.sam);
+ System.out.println("第2个主类对象, 静态成员sam.s: " + ts2.sam);
+ }
+}
+
+class SampleClass {
+ // SampleClass 不能包含任何主类InitialOrderWithoutExtend的成员变量
+ // 否则导致循环引用，循环初始化，调用栈深度过大
+ // 抛出 StackOverFlow 异常
+ // static InitialOrderWithoutExtend iniClass1 = new InitialOrderWithoutExtend("静态成员iniClass1初始化");
+ // InitialOrderWithoutExtend iniClass2 = new InitialOrderWithoutExtend("普通成员成员iniClass2初始化");
+
+ String s;
+
+ SampleClass(String s) {
+ this.s = s;
+ System.out.println(s);
+ }
+
+ SampleClass() {
+ System.out.println("SampleClass默认构造函数被调用");
+ }
+
+ @Override
+ public String toString() {
+ return this.s;
+ }
+}
+
+
+// 静态成员sam初始化
+// static块执行
+// 静态块内初始化sam成员变量
+// 第1个主类对象：
+// 普通成员sam1初始化
+// 普通块执行
+// 普通成员sam2初始化
+// InitialOrderWithoutExtend默认构造函数被调用
+// 第2个主类对象：
+// 普通成员sam1初始化
+// 普通块执行
+// 普通成员sam2初始化
+// InitialOrderWithoutExtend默认构造函数被调用
+// 2个主类对象的静态对象：
+// 第1个主类对象, 静态成员sam.s: 静态块内初始化sam成员变量
+// 第2个主类对象, 静态成员sam.s: 静态块内初始化sam成员变量
\ No newline at end of file
diff --git a/java-base/src/main/java/com/brianway/learning/java/base/constructor/SonClass.java b/java-base/src/main/java/com/brianway/learning/java/base/constructor/SonClass.java
index 6ea4cb4..88aea3e 100644
--- a/java-base/src/main/java/com/brianway/learning/java/base/constructor/SonClass.java
+++ b/java-base/src/main/java/com/brianway/learning/java/base/constructor/SonClass.java
@@ -26,6 +26,7 @@ public SonClass() {
public static void main(String[] args) {
new SonClass("aaa");
+ System.out.println("---------------------------------------");
new SonClass();
}
diff --git a/java-base/src/main/java/com/brianway/learning/java/base/datatype/Boxing.java b/java-base/src/main/java/com/brianway/learning/java/base/datatype/Boxing.java
index 8ac8da7..eab6a5a 100644
--- a/java-base/src/main/java/com/brianway/learning/java/base/datatype/Boxing.java
+++ b/java-base/src/main/java/com/brianway/learning/java/base/datatype/Boxing.java
@@ -19,7 +19,9 @@ public static void main(String[] args) {
System.out.println(c == d);
System.out.println(e == f);
System.out.println(c == (a + b));
+ System.out.println("------------------------------");
System.out.println(c.equals(a + b));
+ System.out.println("------------------------------");
System.out.println(g == (a + b));
System.out.println(g.equals(a + b));
System.out.println(new Integer(2) == new Integer(2));
@@ -34,7 +36,7 @@ public static void main(String[] args) {
true
true 调用 equals(),比较的是值,而不是对象地址
true
-false
+false //x.equals(y)中默认先使用.instanceOf(x)，不同直接return false;
false 比较的是对象地址
*/
\ No newline at end of file
diff --git a/java-base/src/main/java/com/brianway/learning/java/base/datatype/IntegerChanger.java b/java-base/src/main/java/com/brianway/learning/java/base/datatype/IntegerChanger.java
index 45326c8..f112ae2 100644
--- a/java-base/src/main/java/com/brianway/learning/java/base/datatype/IntegerChanger.java
+++ b/java-base/src/main/java/com/brianway/learning/java/base/datatype/IntegerChanger.java
@@ -17,12 +17,18 @@ public class IntegerChanger {
public static void main(String[] args) {
Integer a = 1, b = 2;
+ int c=3,d=4;
System.out.println("before swap a = " + a + ", b = " + b);
swap(a, b);
System.out.println("after swap a = " + a + ", b = " + b);
+ System.out.println("-----------------------------------------");
+ System.out.println("before swap c = " + c + ", d = " + d);
+ swap(c, d);
+ System.out.println("after swap c = " + c + ", d= " + d);
- Integer c = 1;
- System.out.println("(警告:Integer缓存被改了,代码里:Integer c = 1;) 实际c=" + c);
+
+ Integer f = 1;
+ System.out.println("(警告:Integer缓存被改了,代码里:Integer f = 1;) 实际f=" + f);
}
public static void swap(Integer i1, Integer i2) {
@@ -41,4 +47,9 @@ public static void swap(Integer i1, Integer i2) {
}
}
+ public static void swap(int a,int b){
+ int temp=a;
+ a=b;
+ b=temp;
+ }
}
\ No newline at end of file
diff --git a/java-base/src/main/java/com/brianway/learning/java/base/generics/GenericVarargs.java b/java-base/src/main/java/com/brianway/learning/java/base/generics/GenericVarargs.java
index 1a64c5b..eef0f68 100755
--- a/java-base/src/main/java/com/brianway/learning/java/base/generics/GenericVarargs.java
+++ b/java-base/src/main/java/com/brianway/learning/java/base/generics/GenericVarargs.java
@@ -26,5 +26,5 @@ public static void main(String[] args) {
/* Output:
[A]
[A, B, C]
-[, A, B, C, D, E, F, F, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z]
+[A, B, C, D, E, F, F, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z]
*///:~
diff --git a/java-multithread/pom.xml b/java-multithread/pom.xml
index c9f06fe..82caa81 100644
--- a/java-multithread/pom.xml
+++ b/java-multithread/pom.xml
@@ -16,6 +16,16 @@
junit
junit
+
+ org.springframework
+ spring-beans
+ 5.0.4.RELEASE
+
+
+ org.springframework
+ spring-context
+ 5.0.4.RELEASE
+
\ No newline at end of file
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/App.java b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/App.java
new file mode 100644
index 0000000..7377dcf
--- /dev/null
+++ b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/App.java
@@ -0,0 +1,14 @@
+package com.brianway.learning.java.concurrent.Future;
+
+/*
+ * Future模式实现原理(主要目的:去除了主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑)
+ * https://www.cnblogs.com/winkey4986/p/6203225.html
+ */
+public class App {
+ public static void main(String[] args) throws InterruptedException {
+ Client client = new Client();
+ Data data =client.request("kenny");
+ Thread.sleep(2000);
+ System.out.println("数据="+ data.getResult());
+ }
+}
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/Client.java b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/Client.java
new file mode 100644
index 0000000..6fdcfe1
--- /dev/null
+++ b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/Client.java
@@ -0,0 +1,16 @@
+package com.brianway.learning.java.concurrent.Future;
+
+public class Client {
+
+ public Data request(final String str){
+ final FutureData futureData = new FutureData();
+ new Thread(new Runnable() {
+ @Override
+ public void run() {
+ RealData realData = new RealData(str);
+ futureData.setRealData(realData);
+ }
+ }).start();
+ return futureData;
+ }
+}
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/Data.java b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/Data.java
new file mode 100644
index 0000000..6c6bf9b
--- /dev/null
+++ b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/Data.java
@@ -0,0 +1,5 @@
+package com.brianway.learning.java.concurrent.Future;
+
+public interface Data {
+ String getResult() throws InterruptedException;
+}
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/FutureData.java b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/FutureData.java
new file mode 100644
index 0000000..8ade892
--- /dev/null
+++ b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/FutureData.java
@@ -0,0 +1,27 @@
+package com.brianway.learning.java.concurrent.Future;
+
+import com.brianway.learning.java.concurrent.LiftOff;
+
+public class FutureData implements Data {
+
+ private RealData realData =null;
+ private boolean isReady =false;
+
+ public synchronized void setRealData(RealData realData) {
+ if (isReady){
+ return;
+ }
+ this.realData=realData;
+ isReady=true;
+ notifyAll();
+ this.realData = realData;
+ }
+
+ @Override
+ public synchronized String getResult() throws InterruptedException {
+ if (!isReady){
+ wait();
+ }
+ return realData.getResult();
+ }
+}
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/RealData.java b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/RealData.java
new file mode 100644
index 0000000..ad815c3
--- /dev/null
+++ b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/RealData.java
@@ -0,0 +1,22 @@
+package com.brianway.learning.java.concurrent.Future;
+
+
+public class RealData implements Data{
+
+ protected String data;
+
+ public RealData(String data) {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ this.data = data;
+ System.out.println("data has been construct");
+ }
+
+ @Override
+ public String getResult() throws InterruptedException {
+ return data;
+ }
+}
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/ReallyData.java b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/ReallyData.java
new file mode 100644
index 0000000..ae9f942
--- /dev/null
+++ b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/ReallyData.java
@@ -0,0 +1,20 @@
+package com.brianway.learning.java.concurrent.Future;
+
+import java.util.concurrent.Callable;
+
+/*
+ *JDK自带的Future模式
+ */
+public class ReallyData implements Callable {
+ protected String data;
+
+ public ReallyData(String data) {
+ this.data = data;
+ }
+
+ @Override
+ public Object call() throws Exception {
+ Thread.sleep(10000);
+ return data;
+ }
+}
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/Test.java b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/Test.java
new file mode 100644
index 0000000..b94babc
--- /dev/null
+++ b/java-multithread/src/main/java/com/brianway/learning/java/concurrent/Future/Test.java
@@ -0,0 +1,17 @@
+package com.brianway.learning.java.concurrent.Future;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.FutureTask;
+
+public class Test {
+ public static void main(String[] args) throws InterruptedException, ExecutionException {
+ FutureTask futureTask = new FutureTask(new ReallyData("kenny"));
+ ExecutorService executorService = Executors.newFixedThreadPool(1);
+ executorService.submit(futureTask);
+ Thread.sleep(10000);
+ System.out.println("数据= " + futureTask.get());
+ }
+
+}
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/multithread/communication/example7/producer.java b/java-multithread/src/main/java/com/brianway/learning/java/multithread/communication/example7/Producer.java
similarity index 100%
rename from java-multithread/src/main/java/com/brianway/learning/java/multithread/communication/example7/producer.java
rename to java-multithread/src/main/java/com/brianway/learning/java/multithread/communication/example7/Producer.java
diff --git a/java-multithread/src/main/java/com/kenny/Thread/AtomicDemo/AtomicDemo.java b/java-multithread/src/main/java/com/kenny/Thread/AtomicDemo/AtomicDemo.java
new file mode 100644
index 0000000..1ff8e35
--- /dev/null
+++ b/java-multithread/src/main/java/com/kenny/Thread/AtomicDemo/AtomicDemo.java
@@ -0,0 +1,22 @@
+package com.kenny.Thread.AtomicDemo;
+
+import java.util.HashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class AtomicDemo implements Runnable {
+ private AtomicInteger number = new AtomicInteger();
+ @Override
+ public void run() {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ System.out.println(Thread.currentThread().getName()+" : "+getNumber());
+ }
+
+ public int getNumber() {
+ return number.getAndIncrement();
+ }
+}
diff --git a/java-multithread/src/main/java/com/kenny/Thread/AtomicDemo/InsertSort.java b/java-multithread/src/main/java/com/kenny/Thread/AtomicDemo/InsertSort.java
new file mode 100644
index 0000000..26478a8
--- /dev/null
+++ b/java-multithread/src/main/java/com/kenny/Thread/AtomicDemo/InsertSort.java
@@ -0,0 +1,39 @@
+package com.kenny.Thread.AtomicDemo;
+
+
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.context.ApplicationContext;
+
+import java.util.Arrays;
+
+// 插入排序
+public class InsertSort {
+
+ public static void sort(int[] numbers){
+
+ for(int i= 1;i=0 && numbers[preIndex]>current){
+ numbers[preIndex+1]=numbers[preIndex];
+ preIndex--;
+ }
+ numbers[preIndex+1]=current;
+ }
+ }
+
+ public static void main(String [] args){
+ int[] n= new int[]{6,1,7,4,10,2,4,9,3,8};
+ String str = "abebaf";
+ InsertSort.sort(n);
+ char[] c = str.toCharArray();
+ for (int i=0;i list;
+ @Override
+ public void run() {
+ System.out.println("ThreadA is running");
+ int i=1;
+ while (true) {
+
+ if (this.isInterrupted()){
+ System.out.println(currentThread().getName()+" isInterrupted, should be exit");
+ break;
+ }else {
+ System.out.println("i ="+(i++));
+ }
+ }
+ System.out.println("Thread is executed, Thread does not stopped");
+ }
+}
diff --git a/java-multithread/src/main/java/com/kenny/Thread/ThreadB.java b/java-multithread/src/main/java/com/kenny/Thread/ThreadB.java
new file mode 100644
index 0000000..18fbe88
--- /dev/null
+++ b/java-multithread/src/main/java/com/kenny/Thread/ThreadB.java
@@ -0,0 +1,8 @@
+package com.kenny.Thread;
+
+public class ThreadB implements Runnable {
+ @Override
+ public void run() {
+ System.out.println("ThreadB is running");
+ }
+}
diff --git a/java-multithread/src/main/java/com/kenny/Thread/ThreadTest.java b/java-multithread/src/main/java/com/kenny/Thread/ThreadTest.java
new file mode 100644
index 0000000..a41827c
--- /dev/null
+++ b/java-multithread/src/main/java/com/kenny/Thread/ThreadTest.java
@@ -0,0 +1,33 @@
+package com.kenny.Thread;
+
+public class ThreadTest {
+
+ public static void main(String[] args) throws InterruptedException {
+ new ThreadTest().start();
+ }
+ public void start() throws InterruptedException {
+
+// 1.继承Thread类
+
+ try{
+ Thread thread1 = new ThreadA();
+ thread1.start();
+ Thread.sleep(1000);
+ thread1.interrupt();
+ }catch (InterruptedException e){
+ System.out.println("end");
+ }
+
+// 2. 直接创建匿名内部类
+ Thread thread2 = new Thread(){
+ @Override
+ public void run() {
+ System.out.println("Thread2 is start");
+ }
+ };
+ thread2.start();
+// 3.实现runnable接口，并 new Thread(Runnable runnable)
+ Thread thread3 = new Thread(new ThreadB());
+ thread3.start();
+ }
+}
diff --git a/java-multithread/src/main/java/com/kenny/Thread/VolatileDemo/ThreadDemo.java b/java-multithread/src/main/java/com/kenny/Thread/VolatileDemo/ThreadDemo.java
new file mode 100644
index 0000000..a39500e
--- /dev/null
+++ b/java-multithread/src/main/java/com/kenny/Thread/VolatileDemo/ThreadDemo.java
@@ -0,0 +1,23 @@
+package com.kenny.Thread.VolatileDemo;
+
+public class ThreadDemo implements Runnable {
+ private boolean flag =false;
+ @Override
+ public void run() {
+
+ try {
+ Thread.sleep(2000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ flag =true;
+ System.out.println("flag = "+isFlag());
+ }
+
+ public void setFlag(boolean flag) {
+ this.flag = flag;
+ }
+ public boolean isFlag(){
+ return flag;
+ }
+}
diff --git a/java-multithread/src/main/java/com/kenny/Thread/VolatileDemo/VolatileDemo.java b/java-multithread/src/main/java/com/kenny/Thread/VolatileDemo/VolatileDemo.java
new file mode 100644
index 0000000..067972f
--- /dev/null
+++ b/java-multithread/src/main/java/com/kenny/Thread/VolatileDemo/VolatileDemo.java
@@ -0,0 +1,14 @@
+package com.kenny.Thread.VolatileDemo;
+
+public class VolatileDemo {
+ public static void main(String[] args){
+ ThreadDemo demo = new ThreadDemo();
+ new Thread(demo).start();
+ while(true){
+ if (demo.isFlag()){
+ System.out.println("+++++++++");
+ break;
+ }
+ }
+ }
+}
diff --git a/java8/pom.xml b/java8/pom.xml
index 6868bb2..7228afe 100644
--- a/java8/pom.xml
+++ b/java8/pom.xml
@@ -10,6 +10,13 @@
4.0.0
java8
+
+ UTF-8
+ UTF-8
+ 1.8
+ 1.8
+ 4.11
+
diff --git a/java8/src/main/java/com/brianway/learning/java8/effective/async/AsyncShop.java b/java8/src/main/java/com/brianway/learning/java8/effective/async/AsyncShop.java
index d33bcef..e5216d8 100644
--- a/java8/src/main/java/com/brianway/learning/java8/effective/async/AsyncShop.java
+++ b/java8/src/main/java/com/brianway/learning/java8/effective/async/AsyncShop.java
@@ -19,7 +19,6 @@ public AsyncShop(String name) {
this.name = name;
random = new Random(name.charAt(0) * name.charAt(1) * name.charAt(2));
}
-
public Future getPrice(String product) {
/* // 抛出 CompletableFuture 内的异常
CompletableFuture futurePrice = new CompletableFuture<>();
diff --git a/java8/src/main/java/com/brianway/learning/java8/function/Function.java b/java8/src/main/java/com/brianway/learning/java8/function/Function.java
new file mode 100644
index 0000000..d769209
--- /dev/null
+++ b/java8/src/main/java/com/brianway/learning/java8/function/Function.java
@@ -0,0 +1,45 @@
+package com.brianway.learning.java8.function;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.Future;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+public class Function {
+ private static List filter(List list, Predicate predicate){
+ List arrayList = new ArrayList<>();
+ for (T t :list){
+ if (predicate.test(t)){
+ arrayList.add(t);
+ }
+ }
+ return arrayList;
+
+ }
+
+ private static void print(List list, Consumer consumer){
+ for (T t: list){
+ consumer.accept(t);
+ }
+ }
+
+ @Test
+ public void test() {
+ List list=Arrays.asList("abc,","demo","name","film,");
+ List result = filter(list,(String s)->s.endsWith(","));
+ result.forEach(new Consumer() {
+ @Override
+ public void accept(String s) {
+ System.err.println(s);
+ }
+ });
+ print(result,(String s)->{
+ System.out.println(s.toUpperCase());
+ });
+ }
+}
diff --git a/netty/pom.xml b/netty/pom.xml
new file mode 100644
index 0000000..27c2a27
--- /dev/null
+++ b/netty/pom.xml
@@ -0,0 +1,22 @@
+
+
+
+ java-learning
+ com.brianway.learning.java
+ 1.0-SNAPSHOT
+
+ 4.0.0
+
+ netty
+
+
+ io.netty
+ netty-all
+ 4.1.25.Final
+
+
+
+
+
\ No newline at end of file
diff --git a/netty/src/main/java/com/brianway/learning/netty/demo.java b/netty/src/main/java/com/brianway/learning/netty/demo.java
new file mode 100644
index 0000000..82b0cfa
--- /dev/null
+++ b/netty/src/main/java/com/brianway/learning/netty/demo.java
@@ -0,0 +1,6 @@
+package com.brianway.learning.netty;
+
+import io.netty.channel.ChannelInboundHandlerAdapter;
+
+public class demo extends ChannelInboundHandlerAdapter{
+}
diff --git a/pom.xml b/pom.xml
index 3982c6d..7959f3e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -52,6 +52,8 @@
java-io
java8
java-jvm
+ algorithms
+ netty
@@ -60,7 +62,6 @@
junit
junit
${junit.version}
- test