(3),
+ Executors.defaultThreadFactory(),
+ //默认抛出异常
+ //new ThreadPoolExecutor.AbortPolicy()
+ //回退调用者
+ //new ThreadPoolExecutor.CallerRunsPolicy()
+ //处理不来的不处理
+ //new ThreadPoolExecutor.DiscardOldestPolicy()
+ new ThreadPoolExecutor.DiscardPolicy()
+ );
+ //模拟10个用户来办理业务 没有用户就是来自外部的请求线程.
+ try {
+ for (int i = 1; i <= 10; i++) {
+ threadPool.execute(() -> {
+ System.out.println(Thread.currentThread().getName() + "\t 办理业务");
+ });
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ } finally {
+ threadPool.shutdown();
+ }
+ //threadPoolInit();
+ }
+
+ private static void threadPoolInit() {
+ /**
+ * 一池5个处理线程
+ */
+ //ExecutorService threadPool= Executors.newFixedThreadPool(5);
+ /**
+ * 一池一线程
+ */
+ //ExecutorService threadPool= Executors.newSingleThreadExecutor();
+ /**
+ * 一池N线程
+ */
+ ExecutorService threadPool = Executors.newCachedThreadPool();
+ //模拟10个用户来办理业务 没有用户就是来自外部的请求线程.
+ try {
+ for (int i = 1; i <= 20; i++) {
+ threadPool.execute(() -> {
+ System.out.println(Thread.currentThread().getName() + "\t 办理业务");
+ });
+ try {
+ TimeUnit.MICROSECONDS.sleep(200);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ } finally {
+ threadPool.shutdown();
+ }
+ }
+}
+
diff --git a/juc/src/main/java/com/scma/juc/SemaphoreDemo.java b/juc/src/main/java/com/scma/juc/SemaphoreDemo.java
new file mode 100644
index 0000000..e757732
--- /dev/null
+++ b/juc/src/main/java/com/scma/juc/SemaphoreDemo.java
@@ -0,0 +1,36 @@
+package com.scma.juc;
+
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+/**
+ * 信号量的主要用户两个目的,
+ * 一个是用于多ge共享资源的相互排斥使用,
+ * 另一个用于并发资源数的控制
+ * */
+public class SemaphoreDemo {
+ public static void main(String[] args) {
+ //模拟3个停车位
+ Semaphore semaphore = new Semaphore(3);
+ //模拟6部汽车
+ for (int i = 1; i <= 6; i++) {
+ new Thread(() -> {
+ try {
+ //抢到资源
+ semaphore.acquire();
+ System.out.println(Thread.currentThread().getName() + "\t抢到车位");
+ try {
+ TimeUnit.SECONDS.sleep(3);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.println(Thread.currentThread().getName() + "\t 停3秒离开车位");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ } finally {
+ //释放资源
+ semaphore.release();
+ }
+ }, String.valueOf(i)).start();
+ }
+ }
+}
\ No newline at end of file
diff --git a/juc/src/main/java/com/scma/juc/SingletonDemo.java b/juc/src/main/java/com/scma/juc/SingletonDemo.java
new file mode 100644
index 0000000..17e4588
--- /dev/null
+++ b/juc/src/main/java/com/scma/juc/SingletonDemo.java
@@ -0,0 +1,37 @@
+package com.scma.juc;
+
+public class SingletonDemo {
+// private static SingletonDemo INSTANCE = null;
+ private static volatile SingletonDemo INSTANCE = null; //禁止指令重排 线程安全
+
+ private SingletonDemo() {
+ System.out.println(Thread.currentThread().getName() +" new SingletonDemo()...");
+ }
+
+ // public static synchronized SingletonDemo getInstance() {
+ public static SingletonDemo getInstance() {
+ if (INSTANCE == null) {
+ synchronized(SingletonDemo.class) {
+ if (INSTANCE == null) {
+ INSTANCE = new SingletonDemo();
+ }
+ }
+ }
+ return INSTANCE;
+ }
+
+ public static void main(String[] args) {
+// System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
+// System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
+// System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
+
+ // 多线程并发后，情况发生了很大的变化
+ for (int i = 0; i <= 10; i++) {
+ new Thread(() -> {
+ SingletonDemo.getInstance();
+ }, String.valueOf(i)).start();
+ }
+ }
+
+}
+
diff --git a/juc/src/main/java/com/scma/juc/SynchronizedTest.java b/juc/src/main/java/com/scma/juc/SynchronizedTest.java
new file mode 100644
index 0000000..8598787
--- /dev/null
+++ b/juc/src/main/java/com/scma/juc/SynchronizedTest.java
@@ -0,0 +1,55 @@
+package com.scma.juc;
+
+class Phone1 {
+ public synchronized void sendSms() throws Exception {
+ System.out.println(Thread.currentThread().getName() + "\tsendSms");
+ sendEmail();
+ }
+
+ public synchronized void sendEmail() throws Exception {
+
+ System.out.println(Thread.currentThread().getName() + "\tsendEmail");
+ }
+
+}
+
+/**
+ * * Description:
+ * * 可重入锁(也叫做递归锁)
+ * * 指的是同一先生外层函数获得锁后,内层敌对函数任然能获取该锁的代码
+ * * 在同一线程外外层方法获取锁的时候,在进入内层方法会自动获取锁
+ * *
+ * * 也就是说,线程可以进入任何一个它已经标记的锁所同步的代码块
+ * *
+ * * @author veliger@163.com
+ * * @date 2019-04-12 23:36
+ *
+ **/
+public class SynchronizedTest {
+ /**
+ * * t1 sendSms
+ * * t1 sendEmail
+ * * t2 sendSms
+ * * t2 sendEmail
+ * * @param args
+ *
+ */
+ public static void main(String[] args) {
+ Phone1 phone = new Phone1();
+ new Thread(() -> {
+ try {
+ phone.sendSms();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }, "t1").start();
+ new Thread(() -> {
+ try {
+ phone.sendSms();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }, "t2").start();
+ }
+}
+
diff --git a/juc/src/main/java/com/scma/juc/SynchronizedTest2.java b/juc/src/main/java/com/scma/juc/SynchronizedTest2.java
new file mode 100644
index 0000000..fd89460
--- /dev/null
+++ b/juc/src/main/java/com/scma/juc/SynchronizedTest2.java
@@ -0,0 +1,65 @@
+package com.scma.juc;
+
+
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+class Phone implements Runnable {
+ private Lock lock = new ReentrantLock();
+
+ @Override
+ public void run() {
+ get();
+ }
+
+ private void get() {
+ lock.lock();
+ try {
+ System.out.println(Thread.currentThread().getName() + "\tget");
+ set();
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ private void set() {
+ lock.lock();
+ try {
+ System.out.println(Thread.currentThread().getName() + "\tset");
+ } finally {
+ lock.unlock();
+ }
+ }
+}
+
+/**
+ * * Description:
+ * * 可重入锁(也叫做递归锁)
+ * * 指的是同一先生外层函数获得锁后,内层敌对函数任然能获取该锁的代码
+ * * 在同一线程外外层方法获取锁的时候,在进入内层方法会自动获取锁
+ * *
+ * * 也就是说,线程可以进入任何一个它已经标记的锁所同步的代码块
+ * *
+ *
+ **/
+public class SynchronizedTest2 {
+ /**
+ * * Thread-0 get
+ * * Thread-0 set
+ * * Thread-1 get
+ * * Thread-1 set
+ * *
+ * * @param args
+ *
+ */
+ public static void main(String[] args) {
+ Phone phone = new Phone();
+ Thread t3 = new Thread(phone);
+ Thread t4 = new Thread(phone);
+ t3.start();
+ t4.start();
+
+ }
+}
+
+
diff --git a/juc/src/main/java/com/scma/juc/ThreadLocalTest2.java b/juc/src/main/java/com/scma/juc/ThreadLocalTest2.java
index b2b7b8a..4e91901 100644
--- a/juc/src/main/java/com/scma/juc/ThreadLocalTest2.java
+++ b/juc/src/main/java/com/scma/juc/ThreadLocalTest2.java
@@ -37,7 +37,7 @@ public void run() {
}
});
- executorService.shutdown(); //线程池用完需要关闭
+// executorService.shutdown(); //线程池用完需要关闭 提前关闭 会导致异常 因为线程还在执行 但是把线程池关了
}
executorService.shutdown(); //线程池用完需要关闭
diff --git a/juc/src/main/java/com/scma/juc/VolatileDemo.java b/juc/src/main/java/com/scma/juc/VolatileDemo.java
new file mode 100644
index 0000000..b1e25f6
--- /dev/null
+++ b/juc/src/main/java/com/scma/juc/VolatileDemo.java
@@ -0,0 +1,60 @@
+package com.scma.juc;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 验证volatile的可见性
+ * 1.1 假如 int number = 0; number变量之前根本没有添加volatile关键字修饰，没有可见性
+ */
+public class VolatileDemo {
+
+ public static void main(String[] args) {
+ final MyData myData = new MyData();
+
+// new Thread(() -> {
+// System.out.println(Thread.currentThread().getName() + "\t come in");
+//
+// try {
+// TimeUnit.SECONDS.sleep(3);
+// } catch (InterruptedException e) {
+// e.printStackTrace();
+// }
+//
+// myData.add();
+// System.out.println(Thread.currentThread().getName() + "\t updated number value: " + myData.number);
+// }, "AAA").start();
+
+ new Thread(new Runnable() {
+ @Override
+ public void run() {
+ System.out.println(Thread.currentThread().getName() + "\t come in");
+
+ try {
+ TimeUnit.SECONDS.sleep(3);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ myData.add();
+ System.out.println(Thread.currentThread().getName() + "\t updated number value: " + myData.number);
+ }
+ },"AAA").start();
+
+ // 第2个线程就是我们的main线程
+ while (myData.number == 0) {
+ // main线程就一直在这里等待循环，直到number值不再等于0
+ }
+ System.out.println(Thread.currentThread().getName() + "\t mission is over");
+ }
+
+}
+
+class MyData {
+ int number = 0;
+// volatile int number = 0;
+
+ public void add() {
+ this.number = 60;
+ }
+
+}
\ No newline at end of file
From aa94ae3539b0f70b500f0345691f649ddb72b8a1 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sat, 20 Feb 2021 19:56:40 +0800
Subject: [PATCH 04/36] =?UTF-8?q?JUC=E7=90=86=E8=A7=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
juc/pom.xml | 4 +--
.../java/com/scma/interview/RightStore.java | 31 +++++++++++++++++++
.../java/com/scma/juc/MyThreadPoolDemo.java | 2 ++
juc/src/main/java/com/scma/mysql/exists.java | 4 +++
4 files changed, 39 insertions(+), 2 deletions(-)
create mode 100644 juc/src/main/java/com/scma/interview/RightStore.java
create mode 100644 juc/src/main/java/com/scma/mysql/exists.java
diff --git a/juc/pom.xml b/juc/pom.xml
index 2d1d865..9eeac3d 100644
--- a/juc/pom.xml
+++ b/juc/pom.xml
@@ -13,8 +13,8 @@
org.apache.maven.plugins
maven-compiler-plugin
- 6
- 6
+ 8
+ 8
diff --git a/juc/src/main/java/com/scma/interview/RightStore.java b/juc/src/main/java/com/scma/interview/RightStore.java
new file mode 100644
index 0000000..b6c2cd6
--- /dev/null
+++ b/juc/src/main/java/com/scma/interview/RightStore.java
@@ -0,0 +1,31 @@
+package com.scma.interview;
+
+
+// 这个类用于存取一组权限，每个权限用正整数表示的，这组权限存储在rightString属性中；
+// 如果第N个权限存在，rightString第N个字符为“1”，否则，为空格。N是权限字符在字符串
+// 中的位置。
+public class RightStore{
+ private String rightString = "";
+
+ // 如果传入的权限存在，该方法返回true，否则，为false
+ // position传入的权限的位置
+ public boolean getRight(int position){
+ if(position<=0){
+ return false;
+ }
+ char c = rightString.charAt(position-1);
+ return c=='1'?true:false;
+ }
+
+ // 该方法存储或清除传入的权限，如果value为true，存储传入的权限，否则清除该权限。
+ // position传入的权限的位置
+ public void setRight(int position, boolean value){
+ StringBuilder stringBuilder = new StringBuilder(rightString);
+ if(value){
+ stringBuilder.replace(position-1,position,"1");
+ }else{
+ stringBuilder.replace(position-1,position,"");
+ }
+ rightString=stringBuilder.toString();
+ }
+}
diff --git a/juc/src/main/java/com/scma/juc/MyThreadPoolDemo.java b/juc/src/main/java/com/scma/juc/MyThreadPoolDemo.java
index 5ce238c..ff57447 100644
--- a/juc/src/main/java/com/scma/juc/MyThreadPoolDemo.java
+++ b/juc/src/main/java/com/scma/juc/MyThreadPoolDemo.java
@@ -1,5 +1,7 @@
package com.scma.juc;
+import com.sun.deploy.util.StringUtils;
+
import java.util.concurrent.*;
/*
* 你在工作中是如何创建线程池的,是否自定义过线程池使用
diff --git a/juc/src/main/java/com/scma/mysql/exists.java b/juc/src/main/java/com/scma/mysql/exists.java
new file mode 100644
index 0000000..8620d0f
--- /dev/null
+++ b/juc/src/main/java/com/scma/mysql/exists.java
@@ -0,0 +1,4 @@
+package com.scma.mysql;
+
+public class exists {
+}
From 2ab8d73a84d84e3d69cfe8f7b9fcaa2ce1395f10 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sat, 20 Feb 2021 20:30:13 +0800
Subject: [PATCH 05/36] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=96=87=E4=BB=B6?=
=?UTF-8?q?=E7=BB=93=E6=9E=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
{juc => Intervice}/pom.xml | 0
.../java/com/scma/interview/RightStore.java | 0
.../src/main/java/com/scma/juc/ABADemo.java | 0
.../com/scma/juc/AtomicReferenceDemo.java | 0
.../src/main/java/com/scma/juc/CASDemo.java | 0
.../com/scma/juc/ContainerNotSafeDemo.java | 0
.../main/java/com/scma/juc/DeadLockDemo.java | 0
.../java/com/scma/juc/MyThreadPoolDemo.java | 0
.../main/java/com/scma/juc/SemaphoreDemo.java | 0
.../main/java/com/scma/juc/SingletonDemo.java | 0
.../java/com/scma/juc/SynchronizedTest.java | 0
.../java/com/scma/juc/SynchronizedTest2.java | 0
.../java/com/scma/juc/ThreadLocalTest.java | 0
.../java/com/scma/juc/ThreadLocalTest2.java | 0
.../main/java/com/scma/juc/VolatileDemo.java | 0
.../src/main/java/com/scma/mysql/exists.java | 66 +++++++++++++++++++
juc/src/main/java/com/scma/mysql/exists.java | 4 --
17 files changed, 66 insertions(+), 4 deletions(-)
rename {juc => Intervice}/pom.xml (100%)
rename {juc => Intervice}/src/main/java/com/scma/interview/RightStore.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/ABADemo.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/AtomicReferenceDemo.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/CASDemo.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/ContainerNotSafeDemo.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/DeadLockDemo.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/MyThreadPoolDemo.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/SemaphoreDemo.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/SingletonDemo.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/SynchronizedTest.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/SynchronizedTest2.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/ThreadLocalTest.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/ThreadLocalTest2.java (100%)
rename {juc => Intervice}/src/main/java/com/scma/juc/VolatileDemo.java (100%)
create mode 100644 Intervice/src/main/java/com/scma/mysql/exists.java
delete mode 100644 juc/src/main/java/com/scma/mysql/exists.java
diff --git a/juc/pom.xml b/Intervice/pom.xml
similarity index 100%
rename from juc/pom.xml
rename to Intervice/pom.xml
diff --git a/juc/src/main/java/com/scma/interview/RightStore.java b/Intervice/src/main/java/com/scma/interview/RightStore.java
similarity index 100%
rename from juc/src/main/java/com/scma/interview/RightStore.java
rename to Intervice/src/main/java/com/scma/interview/RightStore.java
diff --git a/juc/src/main/java/com/scma/juc/ABADemo.java b/Intervice/src/main/java/com/scma/juc/ABADemo.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/ABADemo.java
rename to Intervice/src/main/java/com/scma/juc/ABADemo.java
diff --git a/juc/src/main/java/com/scma/juc/AtomicReferenceDemo.java b/Intervice/src/main/java/com/scma/juc/AtomicReferenceDemo.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/AtomicReferenceDemo.java
rename to Intervice/src/main/java/com/scma/juc/AtomicReferenceDemo.java
diff --git a/juc/src/main/java/com/scma/juc/CASDemo.java b/Intervice/src/main/java/com/scma/juc/CASDemo.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/CASDemo.java
rename to Intervice/src/main/java/com/scma/juc/CASDemo.java
diff --git a/juc/src/main/java/com/scma/juc/ContainerNotSafeDemo.java b/Intervice/src/main/java/com/scma/juc/ContainerNotSafeDemo.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/ContainerNotSafeDemo.java
rename to Intervice/src/main/java/com/scma/juc/ContainerNotSafeDemo.java
diff --git a/juc/src/main/java/com/scma/juc/DeadLockDemo.java b/Intervice/src/main/java/com/scma/juc/DeadLockDemo.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/DeadLockDemo.java
rename to Intervice/src/main/java/com/scma/juc/DeadLockDemo.java
diff --git a/juc/src/main/java/com/scma/juc/MyThreadPoolDemo.java b/Intervice/src/main/java/com/scma/juc/MyThreadPoolDemo.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/MyThreadPoolDemo.java
rename to Intervice/src/main/java/com/scma/juc/MyThreadPoolDemo.java
diff --git a/juc/src/main/java/com/scma/juc/SemaphoreDemo.java b/Intervice/src/main/java/com/scma/juc/SemaphoreDemo.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/SemaphoreDemo.java
rename to Intervice/src/main/java/com/scma/juc/SemaphoreDemo.java
diff --git a/juc/src/main/java/com/scma/juc/SingletonDemo.java b/Intervice/src/main/java/com/scma/juc/SingletonDemo.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/SingletonDemo.java
rename to Intervice/src/main/java/com/scma/juc/SingletonDemo.java
diff --git a/juc/src/main/java/com/scma/juc/SynchronizedTest.java b/Intervice/src/main/java/com/scma/juc/SynchronizedTest.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/SynchronizedTest.java
rename to Intervice/src/main/java/com/scma/juc/SynchronizedTest.java
diff --git a/juc/src/main/java/com/scma/juc/SynchronizedTest2.java b/Intervice/src/main/java/com/scma/juc/SynchronizedTest2.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/SynchronizedTest2.java
rename to Intervice/src/main/java/com/scma/juc/SynchronizedTest2.java
diff --git a/juc/src/main/java/com/scma/juc/ThreadLocalTest.java b/Intervice/src/main/java/com/scma/juc/ThreadLocalTest.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/ThreadLocalTest.java
rename to Intervice/src/main/java/com/scma/juc/ThreadLocalTest.java
diff --git a/juc/src/main/java/com/scma/juc/ThreadLocalTest2.java b/Intervice/src/main/java/com/scma/juc/ThreadLocalTest2.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/ThreadLocalTest2.java
rename to Intervice/src/main/java/com/scma/juc/ThreadLocalTest2.java
diff --git a/juc/src/main/java/com/scma/juc/VolatileDemo.java b/Intervice/src/main/java/com/scma/juc/VolatileDemo.java
similarity index 100%
rename from juc/src/main/java/com/scma/juc/VolatileDemo.java
rename to Intervice/src/main/java/com/scma/juc/VolatileDemo.java
diff --git a/Intervice/src/main/java/com/scma/mysql/exists.java b/Intervice/src/main/java/com/scma/mysql/exists.java
new file mode 100644
index 0000000..ff5abca
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/mysql/exists.java
@@ -0,0 +1,66 @@
+package com.scma.mysql;
+
+public class exists {
+}
+/*
+CREATE TABLE student(
+ id INT(8) PRIMARY KEY,
+ NAME VARCHAR(10),deptment INT(8)
+)
+
+
+-- 选课表：
+CREATE TABLE select_course
+(
+ ID INT(8) PRIMARY KEY,
+ STUDENT_ID INT(8) ,
+ COURSE_ID INT(8)
+)
+-- 课程表：
+
+CREATE TABLE COURSE
+(
+ ID INT(8) NOT NULL,
+ C_NAME VARCHAR(20),
+ C_NO VARCHAR(10)
+)
+*/
+
+
+
+
+
+
+/*
+-- 1.查询选修了所有课程的学生id、name:（即这一个学生没有一门课程他没有选的。）
+SELECT * FROM student ts WHERE NOT EXISTS
+ (SELECT * FROM COURSE c ,student ts WHERE NOT EXISTS
+ (SELECT sc.* FROM select_course sc,COURSE c ,student ts WHERE sc.student_id=ts.id AND sc.course_id=c.id));
+
+ -- 如果有一门课没有选，则此时(1)
+ SELECT * FROM select_course sc WHERE sc.student_id=ts.id
+AND sc.course_id=c.id -- 存在null，
+
+
+-- 2.查询没有选择所有课程的学生，即没有全选的学生。（存在这样的一个学生，他至少有一门课没有选），
+SELECT id,NAME FROM student WHERE EXISTS
+ (SELECT * FROM COURSE WHERE NOT EXISTS
+ (SELECT * FROM select_course sc WHERE student_id=student.id AND course_id=COURSE.id));
+
+
+
+-- 3.查询一门课也没有选的学生。（不存这样的一个学生，他至少选修一门课程），
+SELECT id,NAME FROM student WHERE NOT EXISTS
+ (SELECT * FROM COURSE WHERE EXISTS
+ (SELECT * FROM select_course sc WHERE student_id=student.id AND course_id=COURSE.id));
+
+
+
+-- 4.查询至少选修了一门课程的学生。
+SELECT id,NAME FROM student WHERE EXISTS
+ (SELECT * FROM COURSE WHERE EXISTS
+ (SELECT * FROM select_course sc WHERE student_id=student.id AND course_id=COURSE.id));
+
+
+
+*/
\ No newline at end of file
diff --git a/juc/src/main/java/com/scma/mysql/exists.java b/juc/src/main/java/com/scma/mysql/exists.java
deleted file mode 100644
index 8620d0f..0000000
--- a/juc/src/main/java/com/scma/mysql/exists.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package com.scma.mysql;
-
-public class exists {
-}
From 25517dc4adce7581acee2924dac4a8d249cf6eb7 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Mon, 22 Feb 2021 20:38:34 +0800
Subject: [PATCH 06/36] =?UTF-8?q?=E7=AE=97=E6=B3=95=E7=AE=80=E4=BB=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../\347\256\227\346\263\225.md" | 1174 +++++++++++++++++
1 file changed, 1174 insertions(+)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/\347\256\227\346\263\225.md"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/\347\256\227\346\263\225.md" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/\347\256\227\346\263\225.md"
new file mode 100644
index 0000000..799f1bb
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/\347\256\227\346\263\225.md"
@@ -0,0 +1,1174 @@
+
+
+
+
+
+
+# 排序
+
+## **总结**
+
+### 选泡快插基 统计堆归希
+
+
+
+### 1.基于比较的排序
+
+#### 1）简单排序（熟练掌握插排）
+
+##### 1、选择排序
+
+人的排序思想；每次选出最大（最小），不稳，特慢。
+
+优化：每次同时选出最大和最小，放在头和尾。
+
+最好、最坏、平均时间复杂度均为N**2
+
+##### 2、冒泡排序
+
+类似鱼吐泡泡；相邻比较交换，每次将最大(或最小)换到正确位置，稳定，特慢
+
+优化：第一次遍历完数组，没有发生交换直接返回。
+
+最好时间复杂度为N，最坏、平均时间复杂度为N**2
+
+##### 3、插入排序
+
+类似扑克插牌；每次将一个数插入到已排好序的数组中。稳定、较快。数组越有序，插入排序越快。当数据量小于60时，一般默认用插排。
+
+优化1：通过二分查找直接找到要插入的位置，执行数组插入的过程。
+
+优化2：在二分查找的前提下，一次找两个待插入数的位置，执行数组插入的过程
+
+最好时间复杂度为N，最坏、平均时间复杂度为N**2
+
+#### 2）复杂排序
+
+##### 1、希尔排序
+
+希尔排序也是对插入排序的优化，但是失去了稳定性。它将每次插入的间隔变大了，跳着插入。因为跳着插，所以不稳。
+
+方法：将普通插入排序的内层循环改成间隔为gap的插入，外层循环不变。在最外层套上一层控制gap变化的循环。
+
+方法一：希尔版gap=a.length/2;gap>0;gap=/2
+
+方法二：Knuth序列：k=1;k=3*k+1
+
+最好时间复杂度：N；平均时间复杂度：N**1.3； 最坏时间复杂度：N平方
+
+##### 2、归并排序
+
+通过分治思想，将对一个数组排序分解成：将一个数组均分成两个子数组，将子数组排好序后再合并成一个数组（merge）。子数组的排序可以递归调用该过程。
+
+所以，归并排序有一个分和合的过程；且会递归调用函数，直至子数组只剩1个数
+
+优化：当数组规模较小时，使用插排。
+
+最好、最坏、平均时间复杂度均为N**2；稳定。
+
+##### 3、快速排序
+
+通过分治思想，将对一个数组排序分解成：取数组中一个数，将大于它的放它右边，小于等于的放左边。将数组分成了两个区：小于等于区、大于区。对两个区再递归调用排序过程。每次排序过程 排好了一个数，且将数组分成两个区。
+
+所以，快速排序有个partition（分）的过程；且会递归调用排序函数，直至子数组只剩1个数。
+
+优化1：每次partition（分）的过程将数组分成三个区，小于区，大于区，等于区。等于区的已排好序，将等于区的起始下标和中止下标记录。将小于区和大于区重新递归调用函数。因为每次排好了一个或多个数，需要空间记录，所以空间复杂度为logN。
+
+优化2 ：随机快排。因为普通快排是取数组的固定位置：尾或头，所以跟数据样本情况有关，最坏时间复杂度会达到N**2（即：已有序时退化成选择排序）。于是改为随机取值，成功消除掉最坏情况，最坏时间复杂度数学统计为NlogN.
+
+优化3：双轴快排。从单边比较优化成为双边比较，当遇到不符合时停下，当另一边也不符合时，交换。
+
+平均、最好时间复杂度：NlogN；普通快排最坏为N**2,随机快排最坏为NlogN
+
+##### 4、堆排序
+
+堆是特殊的完全二叉树，大顶堆是每一个子树的根结点都为最大值的堆。
+
+优先级队列就是用堆实现的。堆一般由数组存储，heapSize表示堆大小。
+
+index为当前元素数组下标，parent为父节点，left为左节点,right为右节点。
+
+left=index*2+1 right=left+1 parent=(index-1)/2
+
+堆的新增heapInsert时间复杂度为logN,堆的构建是将一个个数插入，为O(N)
+
+堆的调整heapIfy时间复杂度为logN,当index上的元素变小时，只需下沉
+
+下沉操作中与子节点比较大小，当比所有子节点大或没有子节点时停止下沉
+
+堆排序过程：
+
+先构建一个大顶堆，然后将根节点与最后一个叶子节点交换，同时heapSize-1(删去堆根节点的同时将最大数排在了数组末尾)；对堆顶元素做heapIfy操作；调整完后再重复删去根节点过程，直至heapSize为0或1.
+
+最好、最坏、平均时间复杂度：NlogN ；不稳定（跳着换的，只跟子父比较交换）
+
+### 2.桶思想的排序（稳定）
+
+1.桶排序
+
+2.基数排序
+
+3.计数排序
+
+## 0.排序相关辅助函数(重点:对数器)
+
+### 1.简单排序的交换函数[位运算版]
+
+(注意:位运算优先级较低,复合运算的时候需要加上小括号)
+
+位运算一般较快.（但特殊情况自己与自己交换会变为0，如快排和堆排）
+
+```java
+public static void swap(int[] arr, int i, int j) {
+ arr[i] = arr[i] ^ arr[j];
+ arr[j] = arr[i] ^ arr[j];
+ arr[i] = arr[i] ^ arr[j];
+}
+```
+
+普通版：（辅助变量temp，适合所有场景，较慢）
+
+```java
+public static void swap(int[] arr, int i, int j) {
+ int temp = arr[i] ;
+ arr[i] = arr[j];
+ arr[j] = temp;
+}
+```
+
+加减版：（适合所有场景，中等，可能越界）
+
+```java
+public static void swap(int[] arr, int i, int j) {
+ arr[i] = arr[i] + arr[j];
+ arr[j] = arr[i] - arr[j];
+ arr[i] = arr[i] - arr[j];
+}
+```
+
+### 2.取两数的平均值,中间值mid
+
+普通版:(相加除2)
+
+```
+mid=(left +right)/2;
+```
+
+优化版1:(减小了越界的可能性)
+
+```
+mid=left +(right-left)/2;
+```
+
+优化版2:(位运算)
+
+```java
+//>>右移,带符号 >>>右移,无符号 右移一位相当于/2
+//注意位移运算外面的小括号,因为位运算优先级低
+//位运算相对较快
+int mid = left + ((right - left) >> 1);
+//heapInsert中直接使用位运算计算父节点，会出现负数-1，数组下边越界
+//当index=0时，parent=(index-1)/2 ；【parent=0】 parrent=(index-1)>>1;【parent=-1】
+//while(index>0&&a[index]>a[((index-1)>>1)]){ //此时需要加上index>0
+```
+
+
+
+### 3.复制数组
+
+1.直接用java系统函数
+
+<1>copyOf(int[], int))**(int[] original, int newLength)
+
+复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
+<2>copyOfRange(int[] original, int from, int to)
+ 将指定数组的指定范围复制到一个新数组。
+
+2.自写copyArray（）
+
+```java
+public static int[] copyArray(int[] arr) {
+ if (arr == null) {
+ return null;
+ }
+ int[] res = new int[arr.length];
+ for (int i = 0; i < arr.length; i++) {
+ res[i] = arr[i];
+ }
+ return res;
+}
+```
+
+
+
+### 4.打印数组
+
+```java
+public static void printArray(int[] arr) {
+ if (arr == null) {
+ return;
+ }
+ for (int i = 0; i < arr.length; i++) {
+ System.out.print(arr[i] + " ");
+ }
+ System.out.println();
+}
+```
+
+### 5.对数器
+
+#### 什么是对数器?
+
+意义:
+
+更快确定自写函数的正确性,直接输出错误用例,方便调试
+
+方法:
+
+1.写一个比较器,比较自写函数与绝对正确函数对数组处理后的结果;
+
+2.比较次数、范围自定义后,数组长度随机,内部值随机(为方便调试,长度较小,次数多)
+
+3.如果不同,返回false并打印不同的那次 原数组和自写函数排序后的数组
+
+4.相同则返回true.因为次数足够多,样本量足够大,所以认为正确
+
+对数器的概念和使用
+0，有一个你想要测的方法a，
+1，实现一个绝对正确但是复杂度不好的方法b，
+2，实现一个随机样本产生器
+3，实现比对的方法
+4，把方法a和方法b比对很多次来验证方法a是否正确。
+5，如果有一个样本使得比对出错，打印样本分析是哪个方法出错
+6，当样本数量很多时比对测试依然正确，可以确定方法a已经正确。
+
+#### 比较器:比较两数组是否相等
+
+<1>系统函数.equals
+
+```java
+Arrays.equals(int[] a,int[] a2)
+```
+
+<2>自写比较
+
+```java
+public static boolean isEqual(int[] arr1, int[] arr2) {
+//特殊情况直接返回
+ if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
+ return false;
+ }
+ if (arr1 == null && arr2 == null) {
+ return true;
+ }
+ if (arr1.length != arr2.length) {
+ return false;
+ }
+ //核心代码:两个数组的比较
+ for (int i = 0; i < arr1.length; i++) {
+ if (arr1[i] != arr2[i]) {
+ return false;
+ }
+ }
+ return true;
+```
+
+#### 生成器:生成随机数组
+
+```java
+public static int[] generateRandomArray(int maxSize, int maxValue) {
+ //长度在自定义范围内随机
+ int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
+ //数值在自定义范围内随机;可0,负数,正数
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
+ }
+ return arr;
+}
+```
+
+#### 对数器使用:不同返回false和相应用例
+
+```java
+int testTime = 500000;
+int maxSize = 100;
+int maxValue = 100;
+boolean succeed = true;
+for (int i = 0; i < testTime; i++) {
+ int[] arr1 = generateRandomArray(maxSize, maxValue);
+ int[] arr2 = copyArray(arr1);
+ int[] arr3= copyArray(arr1);
+ bubbleSort(arr1);
+ comparator(arr2);
+ if (!isEqual(arr1, arr2)) {
+ succeed = false;
+ break;
+ }
+ if (succeed = false) {
+ //原数组,出错测试数据
+ printArray(arr3);
+ //排错"后数组
+ printArray(arr1);
+ //"绝对正确"数组"
+ printArray(arr2);
+ }
+}
+System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+```
+
+## 1.选择排序(慢,不稳定)
+
+```java
+//选择排序(时间复杂度为N**2,空间为1,不稳定)
+//每次找到最小的放在最前面,每次循环比较n次,换一次
+ for (int i = 0; i < arr.length - 1; i++) {
+ int minIndex = i;
+ for (int j = i + 1; j < arr.length; j++) {
+ minIndex = arr[j] < arr[minIndex] ? j : minIndex;
+ }
+ swap(arr, i, minIndex);
+ }
+```
+
+```java
+//选择排序的优化
+//每次循环找到一个最大的和最小的
+//将最大的放在数组最后面,最小的放在前面;
+//*************************
+//交换的时候需要注意:1.先交换最小值,
+// 2.若max存的值为数组最前面,则跟交换后的min互换
+//即:若max=j;swap(a,max,min) 因为min与j已经互换位置了,需要重定向
+for(int j=0;j a[i]) min = i;
+ if (a[max] < a[i]) max = i;
+ }
+ //两组数的交换
+ swap(a,min,j);
+ if(max!=j){ //否则正常交换
+ swap(a,max,a.length-j-1);
+ //如果max==j,先将min和j交换后,max需与min交换
+ }else{swap(a,min,a.length-j-1);}
+
+}
+```
+
+
+
+## 2.冒泡排序(慢,稳定)
+
+```java
+//冒泡排序(时间复杂度为N**2,空间为1,稳定)[最好情况能达到n]
+//每次找到最大的放在最后面,每次循环比较n次,换k次
+ //循环次数,排从尾到第二个的数 n
+ for (int j=a.length-1;j>0;j--) {
+ //一次循环 n
+ for (int i=0;i a[i+1]) swap(a,i,i+1);
+ }
+ }
+```
+
+```java
+//改进版冒泡,最快达到n,已排好情况下,发现一次没换直接返回
+ int k=0;
+ for(int j=a.length;j>0;j--)
+ {
+ for (int i = 0; i < j - 1; i++) {
+ if (a[i] > a[i + 1]) {
+ swap(a, i, i + 1);
+ k++;
+ }
+ }
+ if (k==0) break;
+ }
+```
+
+## 3.插入排序(小样本,基本有序时最快;稳定)
+
+插入排序在工业和实际中应用比较多,当样本量小于60且基本有序时使用;
+
+使用插入排序,可以保证排序数组的稳定性.经常在归并排序和快排中子数组规模小时使用.
+
+### 普通插入排序:
+
+```java
+//插入排序(相对冒泡和选择较好,但时间复杂仍为n**2,空间为1,稳定)
+//思想:同打牌,将新摸到的牌插入到已排好的牌面上
+//操作:每次将后面的数插入到前面已排好的数组中
+ static void insertionSort(int[] a ){ //NK
+ for(int j=1;j 0; i--) { //k
+ if (a[i] < a[i - 1]) swap(a, i, i - 1);
+ }
+ }
+```
+
+### 折半插入(优化:运用二分查找思想找到插入位置)
+
+```java
+ static void halfInSort(int[] a ){
+ //定义边界和中间值
+ int left,mid,right;
+ //定义一个中间变量存待插入的值
+ int temp;
+ for(int j=1;j>1);
+ //如果要插入值比a[mid]小,说明在mid左边,
+ // 将上边界缩小为mid-1
+ if(temp left; i--) {
+ a[i]=a[i-1];
+ }
+ a[left]=temp;
+ }
+```
+
+### pairInsert(优化:一次插入两个)
+
+思想:减少了二分查找的次数
+
+1.将待插入两个数比较大小,通过二分找到较小数应插入的位置;
+
+2.将较小数插入;
+
+3.再从较小数位置到最后找到较大数应插入位置,插入较大数.
+
+## 拓展:二分查找(有序数组查找)
+
+因为插入排序的优化中,使用了二分的思想,所以可以顺便撸出二分查找代码.
+
+前提:数组已排序,查找数字在数组中的位置,不存在返回-1
+
+```java
+static int halfSearch(int[] a,int num){
+ //left为左边界,right为右边界,mid为中间值,index为查找数在数组的位置
+ //初始化
+ int left=0;
+ int right=a.length-1;
+ int index=-1;
+ int mid=-1;
+ //核心比较代码
+ while (left<=right){
+ mid=left+((right-left)>>1);
+ //等于则赋值返回
+ if(a[mid]==num){
+ index = mid;
+ break;
+ }else if (a[mid]0)
+{
+ for (int j = k; j < a.length; j++) {
+ //一次以k为间隔的插入排序
+ for (int i = j; i > k - 1; i-=k) {
+ if (a[i] < a[i - k]) swap(a, i, i - k);
+ }
+ }
+ k=(k-1)/3;
+}
+```
+
+## 5.归并排序(较快,稳定,对象排序最常用)
+
+### 1.归并排序:
+
+1.将数组分为两个数组,将两个数组排序后合并;
+2.子数组的排序可以递归调用归并排序(也可规模较小时用插入排序)
+
+归并分为 mergeSort()分的过程 和merge()合的过程。
+
+mergeSort()分将一个数组均分成左边和右边，左边和右边再递归调用各自的mergeSort();然后再将左边右边merge();
+
+merge()合是将两个有序数组合成一个新数组的过程。通过left，mid，right；将数组分成的两个有序的范围子数组合并。
+
+```java
+//归并排序(时间复杂度为N*logN,稳定;数据库,Java,Python的对象排序都用它)
+//原因(优点):稳定,速度较快,空间复杂度为N;
+//合并时看子数组规模,大时用归并,小时用插入,都稳定;
+// 对应Java中的timiSort
+//思想:将数组分为两个数组,将两个数组排序后合并;
+//子数组的排序可以递归调用归并排序,规模较小时用插入排序
+//涉及理论:插入排序,分治法,递归
+```
+
+```java
+//归并排序 总,入口
+public static void mergeSort(int[] a){
+ if(a==null||a.length<2)return;
+ mergeSort(a,0,a.length-1);
+}
+
+//拆分
+static void mergeSort(int[] a, int left, int right) {
+ if (left == right) {
+ return;
+ } else {
+ //取中间值,拆分
+ int mid = left + ((right - left) >> 1);
+ //拆分左边
+ mergeSort(a, left, mid);
+ //拆分右边
+ mergeSort(a, mid + 1, right);
+ //合并
+ merge(a, left, mid , right);
+ }
+
+}
+```
+
+```java
+//合的过程
+static void merge(int[] a, int left, int mid, int right) {
+ int[] help = new int[right - left + 1];
+ int r = mid+1 ;
+ int i = 0;
+ int l = left;
+ while (l <= mid && r <= right) {
+ help[i++]=a[l]<=a[r]?a[l++]:a[r++];
+ }
+ while (l <= mid) {
+ help[i++] = a[l++];
+ }
+ while (r <= right) {
+ help[i++] = a[r++];
+ }
+ for (int m = 0; m < help.length; m++) {
+ a[left + m] = help[m];
+ }
+}
+```
+
+### 2.归并为什么快？
+
+每次排序的结果后面合并的过程都会用到，所以每次排序没有浪费；采用了分治的思想。
+
+通过这个思想，很多问题可以用归并的思想和算法解决:如小和问题，逆序对问题。
+
+简单排序每次的比较都浪费了，每次循环比较多个数，只排好了一个数的位置。
+
+## 归并相关扩展：
+
+### 递归
+
+#### 总结:
+
+（分治，自动压栈，效率低；所有递归程序可以实现非递归，提高效率）通常用栈来实现。
+
+将原问题分解成与原问题相同、规模更小的子问题；然后通过程序自动压栈,调用函数；简化了代码,但效率会变低;
+
+--每次递归程序会将当前函数的所有信息压入栈中，所以效率低，自己压栈可以优化。
+
+#### 详解：
+
+递归，就是在运行的过程中调用自己。 一个过程或[函数](https://baike.baidu.com/item/函数)在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的[语句](https://baike.baidu.com/item/语句)来定义对象的[无限集合](https://baike.baidu.com/item/无限集合)。
+
+一般来说，递归需要有边界条件、递归前进段和递归返回段。
+
+当边界条件不满足时，递归前进；当边界条件满足时，递归返回。
+
+构成递归需具备的条件：
+
+1. 子问题须与原始问题为同样的事，且更为简单；(分治)
+
+2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。
+
+#### 递归应用
+
+[递归算法](https://baike.baidu.com/item/递归算法)一般用于解决三类问题：
+
+(1)数据的定义是按递归定义的。（Fibonacci[函数](https://baike.baidu.com/item/函数)）
+
+(2)问题解法按[递归算法](https://baike.baidu.com/item/递归算法)实现。
+
+这类问题虽则本身没有明显的递归结构，但用递归求解比迭代求解更简单，如Hanoi问题。
+
+(3)数据的结构形式是按递归定义的。
+
+如二叉树、广义表等，由于结构本身固有的递归特性，则它们的操作可递归地描述。
+
+#### 递归的缺点：
+
+[递归算法](https://baike.baidu.com/item/递归算法)解题相对常用的算法如普通循环等，运行效率较低。因此，应该尽量避免使用递归，除非没有更好的[算法](https://baike.baidu.com/item/算法)或者某种特定情况，递归更为适合的时候。在[递归调用](https://baike.baidu.com/item/递归调用)的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成[栈溢出](https://baike.baidu.com/item/栈溢出)等。
+
+### master公式
+
+master公式的使用：
+T(N) = a*T(N/b) + O(N^d)
+适用范围：递归划分的子问题的规模是一样的；只考虑规模，不考虑常数。
+
+参数说明：N为父问题的样本量；
+N/b为子问题的样本量；
+a为子问题递归调用的次数；（仅看一次函数体的，一步）
+O(N^d)为除了递归过程外，剩下步骤的时间复杂度
+
+T(N) = a*T(N/b) + O(N^d)
+
+1) log(b,a) > d -> 复杂度为O(N^log(b,a))
+2) log(b,a) = d -> 复杂度为O(N^d * logN)
+3) log(b,a) < d -> 复杂度为O(N^d)
+
+### 两数组合并：merge
+
+```java
+//将两个有序数组合并
+static int[] merge(int[] a, int[] b){
+ int[] help=new int[a.length+b.length];
+ //三个数组的初始头指针
+ int l=0;
+ int r=0;
+ int i=0;
+ //合并过程,谁小谁进入help数组
+ while(l> 1);
+ return mergeSort(a, left, mid) +
+ mergeSort(a, mid + 1, right) +
+ merge(a, left, mid, right);
+ }
+ }
+```
+
+### 逆序对问题
+
+在一个数组中，左边的数如果比右边的数大，则折两个数构成一个逆序对，请打印所有逆序对。
+
+举个栗子：3 5 2 1 0 4 9
+
+枚举法：枚举待测位置i，从i+1~n遍历，找出比他小的数的个数，枚举法可得的解有(3,2)，(3,1)，(3,0)，(5,2)，(5,1)，(5,0)，(5,4)，(2,1)，(2,0)，(1,0)。
+
+思想：在merge的过程中返回所有逆序对
+
+```java
+static void merge(int[] a, int left, int mid, int r) {
+ int[] help = new int[r - left + 1];
+ int p2 = mid + 1;
+ int i = 0;
+ int p1 = left;
+ while (p1 <= mid && p2 <= r) {
+ /////////////////////////////////////////
+ //相比归并排序多增加三行代码，返回所有的逆序对
+ if(a[p2]a[r]){
+ swap(a,l,--more);//交换大于基准数时,大于区扩大,指针左移
+ }else {
+ l++;//相等时,等于区指针后移
+ }
+ }
+ swap(a,more,r);//最后将基准数与等于区最后一个元素替换
+ return new int[]{less+1,more};//返回等于区的起始坐标和结束坐标
+}
+static void swap(int[] a,int i,int j){//快排的交换不能用位运算,因为小于区扩大时,可能涉及到自己与自己交换,位运算会将数交换成0
+ int temp=a[i];
+ a[i]=a[j];
+ a[j]=temp;
+}
+```
+
+
+
+## 快排的拓展(partition)
+
+### 问题一:(分两个区)
+
+给定一个数组arr，和一个数num，请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。
+要求额外空间复杂度O(1)，时间复杂度O(N)
+
+```java
+public static void partition(int[] a,int num) {
+ int R = a.length - 1;
+ int less = 0;
+ int more = 1;
+ while (more <= R) {
+ if (a[more] <= num) {
+ swap(a, ++less, more++);
+ } else {
+ more++;
+ }
+ }
+}
+static void swap(int[] a, int i, int j) {
+ int tmp = a[i];
+ a[i] = a[j];
+ a[j] = tmp;
+}
+```
+
+### 问题二（荷兰国旗问题）:（分三个区）
+
+给定一个数组arr，和一个数num，请把小于num的数放在数组的左边，等于num的数放在数组的中间，大于num的数在数组的右边。
+要求额外空间复杂度O(1)，时间复杂度O(N)
+
+```java
+public static void partition(int[] a,int num) {
+ int more = a.length;
+ int less = -1;
+ int mid = 0;
+ while (mid < more) {
+ if (a[mid] < num) {
+ swap(a, ++less, mid++);
+ } else if(a[mid]>num){
+ swap(a,--more,mid);
+ }else{
+ mid++;
+ }
+ }
+}
+
+static void swap(int[] a, int i, int j) {
+ int tmp = a[i];
+ a[i] = a[j];
+ a[j] = tmp;
+}
+```
+
+## 7.堆排序（快，不稳，使用较多）
+
+### 总结
+
+时间复杂度O(N*logN)，额外空间复杂度O(1)
+堆结构非常重要
+1，堆结构的heapInsert与heapify
+2，堆结构的增大和减少
+3，如果只是建立堆的过程，时间复杂度为O(N)
+4，优先级队列结构，就是堆结构
+
+### 大根堆的插入heapInsert
+
+将一个数加入到堆中的过程：
+
+1.首先与父亲节点比较，当比父节点大时，发生交互，并更新自己的index；
+
+2.重复步骤1。直到比父节点小，或者已经到堆顶时，停止。
+
+时间复杂度：logN,最多比较已有数的高度。
+
+```java
+static void heapInsert(int[] a,int index){
+ int parent = (index-1)/2;
+ while(a[parent] 0) { //如果堆还有元素
+ heapIfy(a, 0, heapSize);//调整堆
+ swap(a, 0, --heapSize);//继续取出堆顶元素,与堆最后一个叶子节点元素交换
+ }
+}
+```
+
+## 堆的扩展（堆的结构和使用很重要）
+
+### 什么是二叉堆？
+
+二叉堆是一种特殊的完全二叉树，分为最大堆和最小堆。
+在最大堆中，任何一个父节点的值，都大于或等于它左、右孩子节点的值。
+在最小堆中，任何一个父节点的值，都小于或等于它左、右孩子节点的值。
+
+### 堆的相关知识
+
+二叉堆的根节点叫作堆顶 。
+最大堆和最小堆的特点决定了：最大堆的堆顶是整个堆中的最大元素；最小堆的堆顶是整个堆中的最小元素 。
+
+堆的插入和删除操作，时间复杂度确实是O(logn)。但构建堆的时间复杂度却并不是O(nlogn)，而是O(n)。
+
+二叉堆的存储结构：一般是用数组来存放的。
+
+假设父节点的下标是parent，那么它的左孩子下标就是 2×parent+1 ；右孩子下标就是2×parent+2 。
+
+一个节点的下标为i，它的父亲点下标为：（i-1）/2
+
+### 优先队列
+
+优先队列分为最大优先队列和最小优先队列。
+在最大优先队列中，无论入队顺序如何，当前最大的元素都会优先出队，这是基于最大堆实现的。
+在最小优先队列中，无论入队顺序如何，当前最小的元素都会优先出队，这是基于最小堆实现的。
+
+当用最大堆来实现最大优先队列，每一次入队操作就是堆的插入操作，每一次出队操作就是删除堆顶节点。
+
+## 8.桶排序
+
+**桶排序 (Bucket sort)**是一种排序思想。工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的[排序算法](https://baike.baidu.com/item/排序算法/5399605)或是以递归方式继续使用桶排序进行排序）。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间（[Θ](https://baike.baidu.com/item/Θ)（*n*））。但桶排序并不是 比较排序，他不受到 O(n log n) [下限](https://baike.baidu.com/item/下限/10215216)的影响，受数据状况的影响较大。
+
+1、非基于比较的排序，与被排序的样本的实际数据状况很有关系，所
+以实际中并不经常使用
+2、时间复杂度O(N)，额外空间复杂度O(N)
+3、稳定的排序
+
+计数排序和基数排序是桶排序的实际运用。
+
+## 桶排序运用（求相邻两数的最大差值）
+
+给定一个数组，求如果排序之后，相邻两数的最大差值，要求时间复杂度O(N)，且要求不能用非基于比较的排序。
+
+## 9.计数排序
+
+计数排序是一个非基于比较的排序算法，它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。 [1] 当然这是一种牺牲空间换取时间的做法，而且当O(k)>O(n*log(n))的时候其效率反而不如基于比较的排序（基于比较的排序的时间复杂度在理论上的下限是O(nlog(n)), 如归并排序，堆排序）
+
+最坏、最好、平均时间复杂度：N+K ; 空间复杂度为：N+K
+
+K不能省略，因为K为范围，受范围影响很大，当O(k)>O(n*log(n))时，受益低。
+
+相关资料：https://blog.csdn.net/qq_42111463/article/details/84146915
+
+```java
+ static int[] countSort(int[] a) {
+ int max = Integer.MIN_VALUE;
+ int min = Integer.MAX_VALUE;
+ for (int i = 0; i < a.length; i++) {
+ max = a[i] > max ? a[i] : max;
+ min = a[i] < min ? a[i] : min;
+ }
+ int[] help = new int[max - min + 1];
+ for (int i = 0; i < a.length; i++) {
+ help[a[i] - min]++;//最小的数放在下标为0的位置
+ } //////////////////////////////////////////////////////////
+ //基本数据类型做法,直接输出到原数组排序;空间复杂度为K
+// int j = 0;
+// for (int i = 0; i < help.length; i++) {
+// while (help[i]-- > 0) {//当计数数组不为0时,
+// a[j++] = i + min;//将下标对应的数(i+min)依次填入原数组中
+// }
+// }
+ //////////////////////////////////////////////////////////
+ //对象如何保证稳定性 排名数组和新数组排序,空间复杂度:N+K
+ //1.将统计数组变形为排名数组
+ int sum = 0;//当前排名
+ for (int i = 0; i < help.length; i++)//统计数组做变形，后面的元素等于前面元素的和,排名
+ {
+ sum += help[i];
+ help[i] = sum;
+ }
+//////////////////计数数组变形为排名数组优化
+// for (int i = 1; i < help.length; i++)//统计数组做变形，后面的元素等于前面元素的排名加上自身的计数个数
+// {
+// help[i] += help[i-1];
+// }
+//////////////////取数排序过程分析
+ //此时将计数数组变成了排名数组,
+ //再逆序输出原数组,将原数组的每一个数根据排名数组的下标去找排名,放在新数组中;
+ //同时把排名数组对应位置的名次-1
+ int[] sortArr = new int[a.length];
+ for (int j = a.length - 1; j >= 0; j--) {
+ sortArr[help[(a[j]-min)]-1]=a[j];//a[j]是原数组的数, a[j]-min是在排名数组中对应的下标,
+ // help[a[j]-min]是对应的排名,help[a[j]-min]-1是在新建存放稳定数组中的存放位置
+ help[(a[j]-min)]--;//同时将该下标的排名-1
+ }
+////////////////取数排序可以简化为一条语句
+// for(int i=a.length-1;i>=0;i--){
+// b[--c[a[i]-min]]=a[i];//按存取的方式取出c的元素
+// }
+ return sortArr;//将排好序的稳定数组返回
+ }
+}
+```
+
+```java
+//优化版
+ public static int[] countSort(int[]a){
+ int b[] = new int[a.length];
+ int max = a[0],min = a[0];
+ for(int i:a){
+ max = a[i] > max ? a[i] : max;
+ min = a[i] < min ? a[i] : min;
+ }
+ }//这里k的大小是要排序的数组中，元素大小的极值差+1
+ int c[]=new int[max-min+1];//初始化计数数组
+ for(int i=0;i=0;--i){//稳定取数
+ b[--c[a[i]-min]]=a[i];//按存取的方式取出c的元素
+ }
+ return b;
+ }
+}
+```
+
+## 10.基数排序
+
+基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或“箱排序”（bin sort）。它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用。基数排序法是属于稳定性的排序，受数据状况的影响较大，在某些时候，基数排序法的效率高于其它的稳定性排序法。
+
+基数排序是这样实现的：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
+
+基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。
+
+时间复杂度 ：设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。
+即时间复杂度：N+K；（N+K）*d， d为位数，K为范围（0-9）
+空间效率：
+即空间复杂度：N+K
\ No newline at end of file
From 1dc316bee8f1119faf22e967c7c7c9df82cc6029 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Mon, 22 Feb 2021 20:40:28 +0800
Subject: [PATCH 07/36] =?UTF-8?q?=E7=AE=97=E6=B3=95=E7=AE=80=E4=BB=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
springNote/src/main/java/com/scma/Main.java | 3 +--
springNote/src/main/java/com/scma/User.java | 4 ++++
2 files changed, 5 insertions(+), 2 deletions(-)
diff --git a/springNote/src/main/java/com/scma/Main.java b/springNote/src/main/java/com/scma/Main.java
index 4c0d16a..02a0553 100644
--- a/springNote/src/main/java/com/scma/Main.java
+++ b/springNote/src/main/java/com/scma/Main.java
@@ -4,8 +4,7 @@
public class Main {
public static void main(String[] args) {
-//java的Bean对象
- User user1 = new User();
+
// spring定义的bean对象
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
diff --git a/springNote/src/main/java/com/scma/User.java b/springNote/src/main/java/com/scma/User.java
index 38a7ead..ba6f990 100644
--- a/springNote/src/main/java/com/scma/User.java
+++ b/springNote/src/main/java/com/scma/User.java
@@ -10,4 +10,8 @@ public String getName() {
public void setName(String name) {
this.name = name;
}
+
+ User(String name){
+ this.name=name;
+ }
}
From 9283eab3e76069412573a226134649f3ae27d194 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Mon, 22 Feb 2021 23:08:28 +0800
Subject: [PATCH 08/36] =?UTF-8?q?=E5=8D=95=E4=BE=8B=E6=A8=A1=E5=BC=8F?=
=?UTF-8?q?=E6=89=8B=E5=86=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../singletonle/DoubleCheckSingletonle.java | 37 +++++++++++++++++++
.../main/java/com/scma/singletonle/EHan.java | 16 ++++++++
.../main/java/com/scma/singletonle/LHan.java | 18 +++++++++
.../java/com/scma/singletonle/Singleton.java | 6 +++
.../StaticInnerClassSingletonle.java | 20 ++++++++++
...25\345\210\227\346\250\241\345\274\217.md" | 33 +++++++++++++++++
6 files changed, 130 insertions(+)
create mode 100644 Intervice/src/main/java/com/scma/singletonle/DoubleCheckSingletonle.java
create mode 100644 Intervice/src/main/java/com/scma/singletonle/EHan.java
create mode 100644 Intervice/src/main/java/com/scma/singletonle/LHan.java
create mode 100644 Intervice/src/main/java/com/scma/singletonle/Singleton.java
create mode 100644 Intervice/src/main/java/com/scma/singletonle/StaticInnerClassSingletonle.java
create mode 100644 "Intervice/src/main/java/com/scma/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md"
diff --git a/Intervice/src/main/java/com/scma/singletonle/DoubleCheckSingletonle.java b/Intervice/src/main/java/com/scma/singletonle/DoubleCheckSingletonle.java
new file mode 100644
index 0000000..05472b0
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/singletonle/DoubleCheckSingletonle.java
@@ -0,0 +1,37 @@
+package com.scma.singletonle;
+
+
+/*
+ * 双检锁 的懒汉模式 单例
+ *
+ *又叫双重校验锁，综合了懒汉式和饿汉式两者的优缺点整合而成。
+ * 看上面代码实现中，特点是在synchronized关键字内外都加了一层 if 条件判断，
+ * 这样既保证了线程安全，又比直接上锁提高了执行效率，还节省了内存空间
+ *
+ *
+ * 隐患
+ * 分配内存空间
+ 初始化对象
+ 将对象指向刚分配的内存空间
+ *
+ * 编译器优化 可能指令重排 因此 需要加上 volatile
+ * */
+public class DoubleCheckSingletonle {
+ private volatile static DoubleCheckSingletonle instance; // 禁止指令重排
+// private static DoubleCheckSingletonle instance;
+
+ private DoubleCheckSingletonle() {
+ }
+
+ public static DoubleCheckSingletonle getInstance() {
+ if (instance == null) {
+ synchronized (DoubleCheckSingletonle.class) {
+ if (instance == null) {
+ instance = new DoubleCheckSingletonle(); //分为三步 1 分配内存空间 2初始化对象 3将对象指向内存空间
+ //编译器优化后 可能将 2和3 进行反序 导致 第二个线程进来时 可能拿到 未分配好点对象
+ }
+ }
+ }
+ return instance;
+ }
+}
diff --git a/Intervice/src/main/java/com/scma/singletonle/EHan.java b/Intervice/src/main/java/com/scma/singletonle/EHan.java
new file mode 100644
index 0000000..98dbcd7
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/singletonle/EHan.java
@@ -0,0 +1,16 @@
+package com.scma.singletonle;
+/*
+* 从名字上也很好理解，就是“比较勤”，实例在初始化的时候就已经建好了，不
+* 管你有没有用到，都先建好了再说。
+* 好处是没有线程安全的问题，坏处是浪费内存空间。
+* */
+public class EHan {
+
+ private static EHan instance= new EHan();
+
+ private EHan(){}
+
+ public static EHan getInstance(){
+ return instance;
+ }
+}
diff --git a/Intervice/src/main/java/com/scma/singletonle/LHan.java b/Intervice/src/main/java/com/scma/singletonle/LHan.java
new file mode 100644
index 0000000..bfec495
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/singletonle/LHan.java
@@ -0,0 +1,18 @@
+package com.scma.singletonle;
+/*
+* 就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，
+* 如果有则返回，没有则新建。有线程安全和线程不安全两种写法，
+* 区别就是synchronized关键字。
+* */
+public class LHan {
+ private static LHan instance;
+
+ private LHan() {}
+
+ public static LHan getInstance() {
+ if (instance == null) {
+ instance = new LHan();
+ }
+ return instance;
+ }
+}
diff --git a/Intervice/src/main/java/com/scma/singletonle/Singleton.java b/Intervice/src/main/java/com/scma/singletonle/Singleton.java
new file mode 100644
index 0000000..b4da6b9
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/singletonle/Singleton.java
@@ -0,0 +1,6 @@
+package com.scma.singletonle;
+
+public enum Singleton {
+ INSTANCE;
+ public void anyMethod(){}
+}
diff --git a/Intervice/src/main/java/com/scma/singletonle/StaticInnerClassSingletonle.java b/Intervice/src/main/java/com/scma/singletonle/StaticInnerClassSingletonle.java
new file mode 100644
index 0000000..ffa6e5b
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/singletonle/StaticInnerClassSingletonle.java
@@ -0,0 +1,20 @@
+package com.scma.singletonle;
+/*
+* 效果类似双检锁，但实现更简单。
+* 但这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用
+* */
+public class StaticInnerClassSingletonle {
+ private static StaticInnerClassSingletonle instance;
+
+ private StaticInnerClassSingletonle() {
+ }
+
+ private static StaticInnerClassSingletonle getInstance() {
+ return SingletonleHolder.INSTANCE;
+ }
+
+ // 静态内部类
+ private static class SingletonleHolder {
+ private static final StaticInnerClassSingletonle INSTANCE = new StaticInnerClassSingletonle();
+ }
+}
diff --git "a/Intervice/src/main/java/com/scma/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md" "b/Intervice/src/main/java/com/scma/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md"
new file mode 100644
index 0000000..703a2d4
--- /dev/null
+++ "b/Intervice/src/main/java/com/scma/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md"
@@ -0,0 +1,33 @@
+1、单例类只能有一个实例。
+
+2、单例类必须自己创建自己的唯一实例。
+
+3、单例类必须给所有其他对象提供这一实例。
+
+
+#### 意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
+
+####主要解决：一个全局使用的类频繁地创建与销毁。
+
+#### 何时使用：当您想控制实例数目，节省系统资源的时候。
+
+#### 如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
+
+#### 关键代码：构造函数是私有的。
+
+
+
+###优点：
+1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 2、避免对资源的多重占用（比如写文件操作）。
+
+###缺点：
+没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
+
+### 使用场景：
+```xml
+ 1、要求生产唯一序列号。
+ 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
+ 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
+
+```
+
From 8b6f17993768d6b012063c4c998ff2c7f2e143f6 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Tue, 23 Feb 2021 22:06:49 +0800
Subject: [PATCH 09/36] =?UTF-8?q?=E7=AE=80=E5=8D=95=E8=AF=B4=E6=98=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
Intervice/src/main/java/com/scma/juc/DeadLockDemo.java | 10 ++++++++--
Intervice/src/main/java/com/scma/mysql/exists.java | 1 +
springNote/spring.md | 3 ++-
springNote/src/main/java/com/scma/Main.java | 5 ++---
springNote/src/main/java/com/scma/User.java | 3 ---
...\260\217\347\232\204K\344\270\252\346\225\260.java" | 4 ++--
6 files changed, 15 insertions(+), 11 deletions(-)
diff --git a/Intervice/src/main/java/com/scma/juc/DeadLockDemo.java b/Intervice/src/main/java/com/scma/juc/DeadLockDemo.java
index 2100fe2..f7e633a 100644
--- a/Intervice/src/main/java/com/scma/juc/DeadLockDemo.java
+++ b/Intervice/src/main/java/com/scma/juc/DeadLockDemo.java
@@ -4,6 +4,12 @@
import java.util.concurrent.TimeUnit;
/*
* 产生死锁的主要原因
+*
+* 1、资源互斥
+* 2、资源不可抢占
+* 3、循环等待
+* 4、占有且等待
+*
* */
class HoldThread implements Runnable {
@@ -20,8 +26,8 @@ public void run() {
synchronized (lockA) {
System.out.println(Thread.currentThread().getName() + "\t 自己持有锁" + lockA + "尝试获得" + lockB);
try {
- TimeUnit.SECONDS.sleep(1);
- } catch (InterruptedException e) {
+ TimeUnit.SECONDS.sleep(1); //休眠一会 让 B这个线程进来 占用B这个锁 这样 A 和B 锁 都被占用 A里等待 B释放锁 B里等待A释放锁 造成循环等待 形成死锁
+ } catch (Exception e) {
e.printStackTrace();
}
synchronized (lockB) {
diff --git a/Intervice/src/main/java/com/scma/mysql/exists.java b/Intervice/src/main/java/com/scma/mysql/exists.java
index ff5abca..c30761b 100644
--- a/Intervice/src/main/java/com/scma/mysql/exists.java
+++ b/Intervice/src/main/java/com/scma/mysql/exists.java
@@ -24,6 +24,7 @@ ID INT(8) NOT NULL,
C_NAME VARCHAR(20),
C_NO VARCHAR(10)
)
+
*/
diff --git a/springNote/spring.md b/springNote/spring.md
index c660105..7374526 100644
--- a/springNote/spring.md
+++ b/springNote/spring.md
@@ -10,4 +10,5 @@
6、Suppliers
```
-### spring 笔记
\ No newline at end of file
+### spring 笔记
+
diff --git a/springNote/src/main/java/com/scma/Main.java b/springNote/src/main/java/com/scma/Main.java
index 02a0553..4b03135 100644
--- a/springNote/src/main/java/com/scma/Main.java
+++ b/springNote/src/main/java/com/scma/Main.java
@@ -4,10 +4,9 @@
public class Main {
public static void main(String[] args) {
-
-
-// spring定义的bean对象
+ // spring定义的bean对象
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
User user = applicationContext.getBean("user", User.class);
+ System.out.println(user.getName());
}
}
diff --git a/springNote/src/main/java/com/scma/User.java b/springNote/src/main/java/com/scma/User.java
index ba6f990..6ecdbf0 100644
--- a/springNote/src/main/java/com/scma/User.java
+++ b/springNote/src/main/java/com/scma/User.java
@@ -11,7 +11,4 @@ public void setName(String name) {
this.name = name;
}
- User(String name){
- this.name=name;
- }
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\211\276\345\207\272\346\234\200\345\260\217\347\232\204K\344\270\252\346\225\260.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\211\276\345\207\272\346\234\200\345\260\217\347\232\204K\344\270\252\346\225\260.java"
index d29b5af..f75e089 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\211\276\345\207\272\346\234\200\345\260\217\347\232\204K\344\270\252\346\225\260.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\211\276\345\207\272\346\234\200\345\260\217\347\232\204K\344\270\252\346\225\260.java"
@@ -26,9 +26,9 @@ public static void main(String[] args) {
public static ArrayList GetLeastNumbers_Solution1(int[] arr, int k) {
if (arr.length < k) {
- return new ArrayList<>();
+ return new ArrayList();
}
- ArrayList res =new ArrayList<>();
+ ArrayList res =new ArrayList();
//创建前K个数
int[] a = new int[k];
for (int i = 0; i < k; i++) {
From 1b47867db3c3722daa8e9c4d0f80ba7f0a3b6136 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Tue, 23 Feb 2021 22:29:17 +0800
Subject: [PATCH 10/36] =?UTF-8?q?=E9=BB=98=E5=86=99=E5=86=92=E6=B3=A1?=
=?UTF-8?q?=E6=8E=92=E5=BA=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\346\263\241\346\216\222\345\272\217.java" | 29 +++++++++++++++++--
1 file changed, 26 insertions(+), 3 deletions(-)
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\206\222\346\263\241\346\216\222\345\272\217.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\206\222\346\263\241\346\216\222\345\272\217.java"
index 73c4068..ec5d5a8 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\206\222\346\263\241\346\216\222\345\272\217.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\206\222\346\263\241\346\216\222\345\272\217.java"
@@ -1,11 +1,13 @@
package 排序算法;
-
+/*
+* 稳定 最好：n 平均：n**2 最坏：n**2
+* */
public class 冒泡排序 {
public static void main(String[] args) {
int[] a ={3,4,2,1,-7,0};
- BubbleSort(a);
+// BubbleSort(a);
// maopao2(a);
- print( BubbleSort(a));
+ print( BubbleSortTest(a));
}
@@ -32,4 +34,25 @@ public static int[] BubbleSort(int[] arr){
}
return arr;
}
+
+
+
+ public static int[] BubbleSortTest(int[] arr){
+ int flag=0;
+ for(int i=0;iarr[j+1]){
+ int tem=arr[j+1];
+ arr[j+1]=arr[j];
+ arr[j]=tem;
+ flag++;
+ }
+ }
+ if(flag==0){
+ break;
+ }
+
+ }
+ return arr;
+ }
}
From 24dc8ad5f1b1981206581ca96a2a21267c1513e5 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Tue, 23 Feb 2021 23:23:10 +0800
Subject: [PATCH 11/36] =?UTF-8?q?=E6=8F=92=E5=85=A5=E7=A8=B3=E5=AE=9A=20?=
=?UTF-8?q?=E6=9C=80=E5=A5=BD=E6=98=AFn?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\345\205\245\346\216\222\345\272\217.java" | 46 +++++++++++++------
1 file changed, 31 insertions(+), 15 deletions(-)
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\217\222\345\205\245\346\216\222\345\272\217.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\217\222\345\205\245\346\216\222\345\272\217.java"
index 0e31cba..0ab476a 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\217\222\345\205\245\346\216\222\345\272\217.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\217\222\345\205\245\346\216\222\345\272\217.java"
@@ -1,9 +1,11 @@
package 排序算法;
-
+/*
+ * 稳定 最好：n 平均：n**2 最坏：n**2
+ * */
public class 插入排序 {
public static void main(String[] args) {
int[] a = {3, 4, 2, 1, -7, 0};
- InsertMoveSort(a);
+ InsertTest(a);
for (int i : a) {
System.out.print(i + "\t");
}
@@ -34,19 +36,19 @@ public static int[] InsertMoveSort(int[] arr) {
int j;
//第一种方法
//{3, 4, 2, 1, -7, 0}
- for (i = 1; i < arr.length; i++) {
- int tmp = arr[i];
- for (j = i; j >= 0; j--) {
- if (arr[j - 1] > tmp) {
- arr[j] = arr[j - 1];
- } else {
- break;
- }
- }
- arr[j] = tmp;
- }
- // 第二种方法
- for (int m = 1; i < arr.length; i++) {
+// for (i = 1; i < arr.length-1; i++) {
+// int tmp = arr[i];
+// for (j = i; j >= 0; j--) {
+// if (arr[j - 1] > tmp) {
+// arr[j] = arr[j - 1];
+// } else {
+// break;
+// }
+// }
+// arr[j] = tmp;
+// }
+ // 第二种方法 //{3, 4, 2, 1, -7, 0}
+ for (int m = 1; m < arr.length; m++) {
int tar = arr[m];
int count = m - 1;
while (count >= 0 && arr[count] > tar) {
@@ -57,6 +59,20 @@ public static int[] InsertMoveSort(int[] arr) {
}
return arr;
}
+
+public static int[] InsertTest(int[] arr){
+ for(int j=1;j=0 && arr[count]>tar){
+ arr[count+1]=arr[count];
+ count--;
+ }
+ arr[count+1] =tar;
+ }
+
+ return arr;
+}
}
From 17c1c8561bd8112497c4ca7ed2a01b9563bf8737 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Wed, 24 Feb 2021 23:05:41 +0800
Subject: [PATCH 12/36] =?UTF-8?q?Hash=E7=9B=B8=E5=85=B3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../src/main/java/com/scma/Hash/MyTest.java | 23 ++++++++
.../src/main/java/com/scma/Hash/Person.java | 51 ++++++++++++++++++
.../main/java/com/scma/Hash/TestHashSet.java | 37 +++++++++++++
.../src/main/java/com/scma/Hash/User.java | 53 +++++++++++++++++++
4 files changed, 164 insertions(+)
create mode 100644 Intervice/src/main/java/com/scma/Hash/MyTest.java
create mode 100644 Intervice/src/main/java/com/scma/Hash/Person.java
create mode 100644 Intervice/src/main/java/com/scma/Hash/TestHashSet.java
create mode 100644 Intervice/src/main/java/com/scma/Hash/User.java
diff --git a/Intervice/src/main/java/com/scma/Hash/MyTest.java b/Intervice/src/main/java/com/scma/Hash/MyTest.java
new file mode 100644
index 0000000..f3c4437
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/Hash/MyTest.java
@@ -0,0 +1,23 @@
+package com.scma.Hash;
+
+import java.util.HashSet;
+
+public class MyTest {
+ public static void main(String[] args) {
+ HashSet set = new HashSet<>();
+ User u1 = new User("zhangsan", 3);
+ User u2 = new User("lisi", 7);
+ set.add(u1);
+ set.add(u2);
+ System.out.println("1:" + set);
+// u1.setName("dahuang");
+ u1.name="huang";
+ System.out.println("2:" + set);
+// set.remove(u1);
+ System.out.println("3:" + set);
+ set.add(new User("zhangsan", 3));
+ System.out.println("4:" + set);
+
+// System.out.println(set.contains(user));
+ }
+}
diff --git a/Intervice/src/main/java/com/scma/Hash/Person.java b/Intervice/src/main/java/com/scma/Hash/Person.java
new file mode 100644
index 0000000..6e6fccb
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/Hash/Person.java
@@ -0,0 +1,51 @@
+package com.scma.Hash;
+
+public class Person {
+ String name;
+ int id;
+ public Person(String name, int id) {
+ super();
+ this.name = name;
+ this.id = id;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public void setId(int id) {
+ this.id = id;
+ }
+
+ public Person() {
+ super();
+ }
+ @Override
+ public String toString() {
+ return "Person [name=" + name + ", id=" + id + "]";
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if(!(obj instanceof Person)) {
+ return false;
+ }
+ Person p = (Person) obj;
+ return this.id == p.id && this.name.equals(p.name);
+ }
+ @Override
+ public int hashCode() {
+ int result = 17;
+ result = result * 37 + id;
+ result = result * 37 + name.hashCode();
+ return result;
+ }
+}
diff --git a/Intervice/src/main/java/com/scma/Hash/TestHashSet.java b/Intervice/src/main/java/com/scma/Hash/TestHashSet.java
new file mode 100644
index 0000000..1cf5cea
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/Hash/TestHashSet.java
@@ -0,0 +1,37 @@
+package com.scma.Hash;
+
+import java.util.HashSet;
+
+public class TestHashSet {
+ public static void main(String[] args) {
+ HashSet set = new HashSet();
+ Person p1 = new Person("AA",1001);
+ Person p2 = new Person("BB",1002);
+
+ set.add(p1);
+ set.add(p2);
+ System.out.println("1:" +set);
+ System.out.println("p1的Hash值:" +p1.hashCode());
+ p1.setName("CC");
+ System.out.println("p1的Hash值(修改后):" +p1.hashCode());
+ set.remove(p1);// 此时p1对象已经被修改了，remove()是根据修改后的对象的hash值，找对应的位置，因此此时删除时对应的位置没有值，所以此时没有删除出任何数据。
+ System.out.println("2:" +set);
+
+ Person p3 = new Person("CC", 1001); //虽然此对象与p1对象值完全相等，但是添加时，添加到了该对象所对应的hash桶，而此时的位置与p1不是同一个位置，因为p1是根据修改之前的hash值放入对应的has桶内的，因此他们不冲突
+ set.add(p3);
+ System.out.println("3:" +set);
+
+ set.add(new Person("AA",1001));// 值与未修改前的p1值完全相等，所以对应的hash桶也是同一个位置，添加时找到对应的桶位置后，发现已经有一个对象，然后用equals方法比较值，此时值不相等，因此不产生冲突，依然可以加入到HashSet中
+ System.out.println("4:" +set);
+ }
+}
+/*
+[Person [name=AA, id=1001], Person [name=BB, id=1002]]
+[Person [name=CC, id=1001], Person [name=BB, id=1002]]
+[Person [name=CC, id=1001], Person [name=CC, id=1001], Person [name=BB, id=1002]]
+[Person [name=CC, id=1001], Person [name=CC, id=1001], Person [name=AA, id=1001], Person [name=BB, id=1002]]
+
+
+
+
+*/
diff --git a/Intervice/src/main/java/com/scma/Hash/User.java b/Intervice/src/main/java/com/scma/Hash/User.java
new file mode 100644
index 0000000..44054fa
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/Hash/User.java
@@ -0,0 +1,53 @@
+package com.scma.Hash;
+
+public class User {
+ String name;
+ Integer age;
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public Integer getAge() {
+ return age;
+ }
+
+ public void setAge(Integer age) {
+ this.age = age;
+ }
+
+ public User(String name, Integer age) {
+ super();
+ this.name = name;
+ this.age = age;
+ }
+
+// @Override
+// public String toString() {
+// return "User{" +
+// "name='" + name + '\'' +
+// ", age=" + age +
+// '}';
+// }
+
+
+ @Override
+ public boolean equals(Object obj) {
+ if(!(obj instanceof User)) {
+ return false;
+ }
+ User p = (User) obj;
+ return this.age == p.age && this.name.equals(p.name);
+ }
+ @Override
+ public int hashCode() {
+ int result = 17;
+ result = result * 37 + age;
+ result = result * 37 + name.hashCode();
+ return result;
+ }
+}
From 50ecfa41d24e3637e5d5fa84a9408ebf1713d880 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Thu, 25 Feb 2021 23:12:41 +0800
Subject: [PATCH 13/36] =?UTF-8?q?synchronized=E5=85=B3=E9=94=AE=E5=AD=97?=
=?UTF-8?q?=E7=90=86=E8=A7=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../synchronized_test/synchronizedTest.java | 27 +++++++++++++++++++
1 file changed, 27 insertions(+)
create mode 100644 Intervice/src/main/java/com/scma/synchronized_test/synchronizedTest.java
diff --git a/Intervice/src/main/java/com/scma/synchronized_test/synchronizedTest.java b/Intervice/src/main/java/com/scma/synchronized_test/synchronizedTest.java
new file mode 100644
index 0000000..e318289
--- /dev/null
+++ b/Intervice/src/main/java/com/scma/synchronized_test/synchronizedTest.java
@@ -0,0 +1,27 @@
+package com.scma.synchronized_test;
+
+/*
+ * 关键字synchronized 原理
+ * */
+public class synchronizedTest implements Runnable {
+ public static int num = 0;
+
+ @Override
+ public void run() {
+ for (int i = 0; i < 1000; i++) {
+ num++;
+ }
+ }
+
+ public static void main(String[] args) {
+ for(int i=0;i<100;i++){
+ new Thread(new synchronizedTest()).start();
+ }
+ try {
+ Thread.sleep(2000); //等所有线程执行++ 操作完成
+ } catch ( Exception e) {
+
+ }
+ System.out.println(num);
+ }
+}
\ No newline at end of file
From c436ef4f00457a82061b1ffe41ec41de76d0e4b2 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Fri, 26 Feb 2021 23:44:38 +0800
Subject: [PATCH 14/36] =?UTF-8?q?=E7=AC=AC=E4=B8=8D=E7=9F=A5=E9=81=93?=
=?UTF-8?q?=E5=A4=9A=E5=B0=91=E6=AC=A1=E6=A2=A6=E5=BC=80=E5=A7=8B=E7=9A=84?=
=?UTF-8?q?=E5=9C=B0=E6=96=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../src/main/java/leetcode/TwoSum.java" | 36 +++++++++++++++++++
1 file changed, 36 insertions(+)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java"
new file mode 100644
index 0000000..38d65b9
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java"
@@ -0,0 +1,36 @@
+package leetcode;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+/*
+ * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
+ * 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
+ * */
+public class TwoSum {
+ // {1,3,4,5,5} 7
+ public static void main(String[] args) {
+ int[] test = {1, 1,2,2,3,3, 4,};
+ int tar = 7;
+ int[] ints = twoSum(test, tar);
+ System.out.println(twoSum(test, tar));
+ }
+
+ public static int[] twoSum(int[] arr, int tar) {
+ HashMap map = new HashMap();
+ for (int i = 0; i < arr.length; i++) {
+ map.put(arr[i], i);
+ }
+
+ for (int j = 0; j < arr.length; j++) {
+ if (map.containsKey(tar - arr[j])) {
+ if (j != map.get(tar - arr[j])) {
+ return new int[]{j, map.get(tar - arr[j])};
+ }
+ }
+ }
+
+ return null;
+ }
+}
From 673b576b45bafde7cb1a1a8998f3646e85233377 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Fri, 26 Feb 2021 23:50:21 +0800
Subject: [PATCH 15/36] =?UTF-8?q?=E7=AC=AC=E4=B8=8D=E7=9F=A5=E9=81=93?=
=?UTF-8?q?=E5=A4=9A=E5=B0=91=E6=AC=A1=E6=A2=A6=E5=BC=80=E5=A7=8B=E7=9A=84?=
=?UTF-8?q?=E5=9C=B0=E6=96=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../src/main/java/leetcode/TwoSum.java" | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java"
index 38d65b9..9364119 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java"
@@ -11,7 +11,7 @@
public class TwoSum {
// {1,3,4,5,5} 7
public static void main(String[] args) {
- int[] test = {1, 1,2,2,3,3, 4,};
+ int[] test = {1, 1, 2, 2, 3, 3, 4,};
int tar = 7;
int[] ints = twoSum(test, tar);
System.out.println(twoSum(test, tar));
@@ -31,6 +31,20 @@ public static int[] twoSum(int[] arr, int tar) {
}
}
+ return null;
+ }
+//优化
+ public static int[] twoSum2(int[] arr, int tar) {
+ if (arr == null || arr.length == 0) {
+ return new int[0];
+ }
+ HashMap map = new HashMap();
+ for (int i = 0; i < arr.length; i++) {
+ if(map.containsKey(tar-arr[i])){
+ return new int[]{i,map.get(tar-arr[i])};
+ }
+ map.put(arr[i],i);
+ }
return null;
}
}
From d705efe918ccba0117c7cafca70847aaebd7d344 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 28 Feb 2021 15:32:16 +0800
Subject: [PATCH 16/36] =?UTF-8?q?=E7=AC=AC=E4=B8=8D=E7=9F=A5=E9=81=93?=
=?UTF-8?q?=E5=A4=9A=E5=B0=91=E6=AC=A1=E6=A2=A6=E5=BC=80=E5=A7=8B=E7=9A=84?=
=?UTF-8?q?=E5=9C=B0=E6=96=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../main/java/leetcode_normal/TwoSum.java" | 12 ++---
.../main/java/leetcode_normal/TwoSum1.java" | 44 +++++++++++++++++++
2 files changed, 50 insertions(+), 6 deletions(-)
rename "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java" => "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum.java" (89%)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum1.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum.java"
similarity index 89%
rename from "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java"
rename to "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum.java"
index 9364119..a5acb57 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode/TwoSum.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum.java"
@@ -1,8 +1,6 @@
-package leetcode;
+package leetcode_normal;
-import java.util.Arrays;
import java.util.HashMap;
-import java.util.List;
/*
* 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
@@ -11,9 +9,9 @@
public class TwoSum {
// {1,3,4,5,5} 7
public static void main(String[] args) {
- int[] test = {1, 1, 2, 2, 3, 3, 4,};
- int tar = 7;
- int[] ints = twoSum(test, tar);
+ int[] test = {2,3,4};
+ int tar =6;
+ int[] ints = twoSum2(test, tar);
System.out.println(twoSum(test, tar));
}
@@ -40,10 +38,12 @@ public static int[] twoSum2(int[] arr, int tar) {
}
HashMap map = new HashMap();
for (int i = 0; i < arr.length; i++) {
+
if(map.containsKey(tar-arr[i])){
return new int[]{i,map.get(tar-arr[i])};
}
map.put(arr[i],i);
+
}
return null;
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum1.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum1.java"
new file mode 100644
index 0000000..e66a3fc
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum1.java"
@@ -0,0 +1,44 @@
+package leetcode_normal;
+
+/*
+* 给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target
+* 函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，
+* 所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。
+*
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted
+* */
+public class TwoSum1 {
+ public static void main(String[] args) {
+ int[] arr = {0,2,3,5, 7, 11, 15};// 9
+ int[] ints = twoSum1(arr, 9);
+ System.out.println(ints);
+ }
+
+ public static int[] twoSum1(int[] arr, int tar) {
+ for (int i = 0; i < arr.length; i++) {
+ int t = tar - arr[i];
+ int m=BinarySearch(arr,0,arr.length-1,t);
+ if(m!=-1){
+ return new int[]{i,m};
+ }
+ }
+ return null;
+ }
+
+ public static int BinarySearch(int[] arr, int l, int r, int tar) {
+
+ while (r >= l) {
+ int mid = l + (r - l) / 2;
+ if(arr[mid]==tar){
+ return mid;
+ }
+ if(arr[mid]>tar){
+ r=mid-1;
+ }else{
+ l=mid+1;
+ }
+ }
+ return -1;
+ }
+}
From 9ba2856a5a0e7c96a5d7c33551b009b296346d20 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 28 Feb 2021 20:03:25 +0800
Subject: [PATCH 17/36] =?UTF-8?q?=E5=B2=9B=E9=97=AE=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\345\262\233\351\227\256\351\242\230.java" | 65 +++++++++++++++++++
1 file changed, 65 insertions(+)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\271\266\346\237\245\351\233\206/\345\262\233\351\227\256\351\242\230.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\271\266\346\237\245\351\233\206/\345\262\233\351\227\256\351\242\230.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\271\266\346\237\245\351\233\206/\345\262\233\351\227\256\351\242\230.java"
new file mode 100644
index 0000000..d131ca4
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\271\266\346\237\245\351\233\206/\345\262\233\351\227\256\351\242\230.java"
@@ -0,0 +1,65 @@
+package 并查集;
+
+/*
+ * 一个矩阵中只有0和1 每个位置都可以和自己的上下左右 四个位置相连
+ * 如果一片1 连在一起，这个部分叫做一个岛 求一个矩阵中有几个岛
+ *
+ * 举例
+ * 0 0 1 0 1 0
+ * 1 1 1 0 1 0
+ * 1 0 0 1 0 0
+ * 0 0 0 0 0 0
+ *
+ * 这个矩阵中有三个岛
+ * */
+//并查集 求法 多CPU处理 并行
+/*
+将二维数组区域划分成多个区域 对每个区域求感染区域 将区域特殊标做标记 不同区域标记不同
+多个区域算出来有几个岛之后 对边界进行合并 相同标记的合并只保留一个区域
+多CUP并行处理，能加快计算速度
+* */
+
+
+//使用常规解法 不使用并查集
+public class 岛问题 {
+ public static void main(String[] args) {
+ int[][] m1 = {
+ {0, 0, 1, 0, 1, 0},
+ {1, 1, 1, 0, 1, 0},
+ {1, 0, 0, 1, 0, 0},
+ {0, 0, 0, 0, 0, 0}
+ };
+ int alent = alent(m1);
+ System.out.println(alent);
+ }
+
+ public static int alent(int[][] m) {
+ if (m.length == 0) {
+ return 0;
+ }
+ int M = m.length;
+ int N = m[0].length;
+ int res = 0;
+ for (int i = 0; i < M; i++) {
+ for (int j = 0; j < N; j++) {
+ if (m[i][j] == 1) {
+ res++;
+ infect(m, i, j, M, N);
+ }
+ }
+ }
+ return res;
+ }
+
+ private static void infect(int[][] m, int i, int j, int M, int N) {
+ if (i < 0 || i >= M || j < 0 || j >= N || m[i][j] != 1) {
+ return;
+ }
+ m[i][j] = 2;
+ infect(m, i + 1, j, M, N);
+ infect(m, i - 1, j, M, N);
+ infect(m, i, j + 1, M, N);
+ infect(m, i, j - 1, M, N);
+ }
+
+}
From 81d427c1a5554bd85ee1f3ba93e92996ad62bb1c Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 28 Feb 2021 20:10:59 +0800
Subject: [PATCH 18/36] =?UTF-8?q?=E5=B2=9B=E9=97=AE=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../\345\262\233\351\227\256\351\242\230.java" | 11 ++++++++---
1 file changed, 8 insertions(+), 3 deletions(-)
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\271\266\346\237\245\351\233\206/\345\262\233\351\227\256\351\242\230.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\271\266\346\237\245\351\233\206/\345\262\233\351\227\256\351\242\230.java"
index d131ca4..bf64fe2 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\271\266\346\237\245\351\233\206/\345\262\233\351\227\256\351\242\230.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\271\266\346\237\245\351\233\206/\345\262\233\351\227\256\351\242\230.java"
@@ -23,6 +23,11 @@
//使用常规解法 不使用并查集
public class 岛问题 {
public static void main(String[] args) {
+ String AA="12432432";
+ String[] split = AA.split("");
+//boolean Boolean
+ char[] chars = AA.toCharArray();
+ System.out.println(chars);
int[][] m1 = {
{0, 0, 1, 0, 1, 0},
{1, 1, 1, 0, 1, 0},
@@ -41,10 +46,10 @@ public static int alent(int[][] m) {
int N = m[0].length;
int res = 0;
for (int i = 0; i < M; i++) {
- for (int j = 0; j < N; j++) {
- if (m[i][j] == 1) {
+ for (int j = 0; j < N; j++) { //循环所有
+ if (m[i][j] == 1) { //如果有岛屿 那么数量++ 然后将这一片都给感染掉 下次遍历的时候 就不进行岛屿数量++操作了
res++;
- infect(m, i, j, M, N);
+ infect(m, i, j, M, N); //感染函数
}
}
}
From 2a23d8b07165048e3d6485e6d6cd1162946ccd76 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 28 Feb 2021 22:57:50 +0800
Subject: [PATCH 19/36] =?UTF-8?q?=E8=B4=AA=E5=BF=83-=E5=88=86=E9=BB=84?=
=?UTF-8?q?=E9=87=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\345\210\206\351\273\204\351\207\221.java" | 45 +++++++++++++++++++
1 file changed, 45 insertions(+)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\345\210\206\351\273\204\351\207\221.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\345\210\206\351\273\204\351\207\221.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\345\210\206\351\273\204\351\207\221.java"
new file mode 100644
index 0000000..fc2659c
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\345\210\206\351\273\204\351\207\221.java"
@@ -0,0 +1,45 @@
+package 贪心;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+/*
+* 一块金条 三个人分 【10，20，30】 表示每个人分的份数 总长度为 求和 60
+* 每切割一次 需要花费长度个硬币
+* 60先分成10和50 需要花费60个硬币 50在分成30和20 需要50个硬币 总共100硬币
+* 60先分成30和30 花费60硬币 30分成10和20 需要30个硬币 总共90硬币
+* */
+public class 分黄金 {
+
+ public static void main(String[] args) {
+ int[] arr={10,20,30};
+ int i = lessMoney(arr);
+ System.out.println(i);
+
+ }
+
+ public static int lessMoney(int[] arr){
+ PriorityQueue pQ = new PriorityQueue(new MM());
+ for(int i=0;i1){
+ cur=pQ.poll()+pQ.poll();
+ sum+=cur;
+ pQ.add(cur);
+ }
+
+ return sum;
+ }
+
+ public static class MM implements Comparator{
+ @Override
+ public int compare(Integer o1, Integer o2) {
+ return o1-o2;
+ }
+}
+
+}
\ No newline at end of file
From ab88e7b95e5a5a99edd45e69b5672d1a39241fea Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Mon, 1 Mar 2021 19:39:56 +0800
Subject: [PATCH 20/36] =?UTF-8?q?=E7=AE=97=E6=B3=95=E7=AE=80=E4=BB=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\345\271\266\346\216\222\345\272\217.java" | 8 +--
...\346\263\241\346\216\222\345\272\217.java" | 1 -
...\345\260\224\346\216\222\345\272\217.java" | 58 ++++++++++------
...\345\271\266\346\216\222\345\272\217.java" | 54 +++++++--------
...\351\200\237\346\216\222\345\272\217.java" | 32 +++++----
...347\232\204K\344\270\252\346\225\260.java" | 3 +-
...\345\205\245\346\216\222\345\272\217.java" | 18 +++--
...\346\213\251\346\216\222\345\272\217.java" | 40 ++++++++---
...\345\210\206\351\273\204\351\207\221.java" | 35 +++++-----
...\345\244\247\346\224\266\347\233\212.java" | 66 +++++++++++++++++++
.../READEME.md" | 19 ++++++
.../coins1.java" | 32 +++++++++
12 files changed, 261 insertions(+), 105 deletions(-)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\351\241\271\347\233\256\346\234\200\345\244\247\346\224\266\347\233\212.java"
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\200\222\345\275\222\345\222\214\345\212\250\346\200\201\350\247\204\345\210\222/READEME.md"
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\200\222\345\275\222\345\222\214\345\212\250\346\200\201\350\247\204\345\210\222/coins1.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\344\270\244\344\270\252\346\225\260\347\273\204\345\220\210\345\271\266\346\216\222\345\272\217.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\344\270\244\344\270\252\346\225\260\347\273\204\345\220\210\345\271\266\346\216\222\345\272\217.java"
index 449c69c..b2f2f2b 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\344\270\244\344\270\252\346\225\260\347\273\204\345\220\210\345\271\266\346\216\222\345\272\217.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\344\270\244\344\270\252\346\225\260\347\273\204\345\220\210\345\271\266\346\216\222\345\272\217.java"
@@ -2,10 +2,10 @@
public class 两个数组合并排序 {
public static void main(String[] args) {
- int[] a = {4, 2, 6, 3, 0, 0, 0, 0, 0, 0};
- int[] b = {5, 1, 7};
- mergeArray(a, 4, b, 3);//1
-// myMerge(a, 4, b, 3); //2
+ int[] a = {1,5,7,8,9,17,20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ int[] b = {0,2,4,6,7,17,18,23,25};
+// mergeArray(a, 7, b, 9);//1
+ myMerge(a, 7, b, 9); //2
System.out.print(a.toString());
System.out.print(a.toString());
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\206\222\346\263\241\346\216\222\345\272\217.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\206\222\346\263\241\346\216\222\345\272\217.java"
index ec5d5a8..bf93fbc 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\206\222\346\263\241\346\216\222\345\272\217.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\206\222\346\263\241\346\216\222\345\272\217.java"
@@ -51,7 +51,6 @@ public static int[] BubbleSortTest(int[] arr){
if(flag==0){
break;
}
-
}
return arr;
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\270\214\345\260\224\346\216\222\345\272\217.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\270\214\345\260\224\346\216\222\345\272\217.java"
index 70c7d84..4e954a3 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\270\214\345\260\224\346\216\222\345\272\217.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\270\214\345\260\224\346\216\222\345\272\217.java"
@@ -5,41 +5,57 @@ public static void main(String[] args) {
int[] a = {3, 4, 2, 1, -7, 0};
// ShellSort(a);
ShellSortMove(a);
- for(int a1:a){
- System.out.print(a1);
+ for (int a1 : a) {
+ System.out.print(a1+"\t");
}
System.out.print(a);
}
- public static int[] ShellSort(int[] arr){
- for(int jap=arr.length/2;jap>0;jap/=2){
- for (int i=jap;i=0 && arr[x] 0; jap /= 2) {
+ for (int i = jap; i < arr.length; i++) {
+ int x = i;
+ while (x - jap >= 0 && arr[x] < arr[x - jap]) {
+ int tmp = arr[x];
+ arr[x] = arr[x - jap];
+ arr[x - jap] = tmp;
+ x = x - jap;
}
}
}
- return arr;
+ return arr;
}
//基于移动的希尔排序 int[] a = {3, 4, 2, 1, -7, 0};
- public static int[] ShellSortMove(int[] arr){
- for(int jap=arr.length/2;jap>0;jap/=2){
- for(int i=jap;i=0 && tmp 0; jap /= 2) {
+ for (int i = jap; i < arr.length; i++) {
+ int tmp = arr[i];
+ int x = i;
+ while (x - jap >= 0 && tmp < arr[x - jap]) {
+ arr[x] = arr[x - jap];
+ x = x - jap;
}
- arr[x] =tmp;
+ arr[x] = tmp;
+ }
+ }
+ return arr;
+ }
+
+ /*
+ public static int[] InsertTest(int[] arr) {
+ for (int j = 1; j < arr.length; j++) {
+ int tar = arr[j];
+ int count = j - 1;
+ while (count >= 0 && arr[count] > tar) {
+ arr[count + 1] = arr[count];
+ count--;
}
+ arr[count + 1] = tar;
}
return arr;
}
+ */
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\275\222\345\271\266\346\216\222\345\272\217.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\275\222\345\271\266\346\216\222\345\272\217.java"
index f05a187..14ddc77 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\275\222\345\271\266\346\216\222\345\272\217.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\275\222\345\271\266\346\216\222\345\272\217.java"
@@ -3,44 +3,44 @@
public class 归并排序 {
public static void main(String[] args) {
int[] a = {3, 4, 2, 1, -7, 0};
- int[] tmp =new int[a.length];
- sort(a,0,a.length-1,tmp);
+ int[] tmp = new int[a.length];
+ sort(a, 0, a.length - 1, tmp);
// mergeSort(a);
System.out.print(a);
}
- public static void sort(int[] arr,int l,int r ,int[] tmp){
-
- if(r>l){
- int mid =(l+r)/2;
- sort(arr,l,mid,tmp);
- sort(arr,mid+1,r,tmp);
- mergeSort(arr,l,mid,r,tmp);
+ public static void sort(int[] arr, int l, int r, int[] tmp) {
+ if (r > l) {
+ int mid = (l + r) / 2;
+ sort(arr, l, mid, tmp);
+ sort(arr, mid + 1, r, tmp);
+ mergeSort(arr, l, mid, r, tmp);
}
}
- public static int[] mergeSort(int[] arr,int left,int mid,int right,int[] temp){
- System.out.print("Merge次数");
- int i=left;
- int j =mid+1;
- int t=0;
- while(i<=mid && j<=right){
- if(arr[i]>arr[j]){
- temp[t++]=arr[j++];
- }else{
- temp[t++]=arr[i++];
+
+ public static void mergeSort(int[] arr, int left, int mid, int right, int[] temp) {
+ System.out.print("Merge次数"); // 3, 4, 2, 1, -7, 0
+ int i = left;
+ int j = mid + 1;
+ int t = 0;
+ while (i <= mid && j <= right) {
+ if (arr[i] > arr[j]) {
+ temp[t++] = arr[j++];
+ } else {
+ temp[t++] = arr[i++];
}
}
- while(i<=mid){
- temp[t++] =arr[i++];
+ while (i <= mid) {
+ temp[t++] = arr[i++];
}
- while(j<=right){
- temp[t++] =arr[j++];
+ while (j <= right) {
+ temp[t++] = arr[j++];
}
- t=0;
- while(right>=left){
- arr[left++]=temp[t++];
+ t = 0;
+ while (right >= left) {
+ arr[left++] = temp[t++];
}
- return arr;
+// return arr;
}
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\277\253\351\200\237\346\216\222\345\272\217.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\277\253\351\200\237\346\216\222\345\272\217.java"
index 209586f..1c66d27 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\277\253\351\200\237\346\216\222\345\272\217.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\345\277\253\351\200\237\346\216\222\345\272\217.java"
@@ -5,25 +5,29 @@
public class 快速排序 {
public static void main(String[] args) {
int[] a = {3, 4, 2, 1, -7, 0};
- QuickSort(a,0,a.length-1);
+ QuickSort(a, 0, a.length - 1);
System.out.print(a);
}
- public static void QuickSort(int[] arr,int low,int high){
- int l=low;
- int r =high;
- if(l>r){
+ public static void QuickSort(int[] arr, int low, int high) {
+ int l = low;
+ int r = high;
+ if (l > r) {
return;
}
- int tar=arr[l];
- while(r>l){
- while(r>l&& arr[r]>tar){r--;}
- arr[l]=arr[r];
- while(r>l && arr[l] l) {
+ while (r > l && arr[r] > tar) {
+ r--;
+ }
+ arr[l] = arr[r];
+ while (r > l && arr[l] < tar) {
+ l++;
+ }
+ arr[r] = arr[l];
}
- arr[l] =tar;
- QuickSort(arr,low,l-1);
- QuickSort(arr,l+1,high);
+ arr[l] = tar;
+ QuickSort(arr, low, l - 1);
+ QuickSort(arr, l + 1, high);
}
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\211\276\345\207\272\346\234\200\345\260\217\347\232\204K\344\270\252\346\225\260.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\211\276\345\207\272\346\234\200\345\260\217\347\232\204K\344\270\252\346\225\260.java"
index f75e089..e11c276 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\211\276\345\207\272\346\234\200\345\260\217\347\232\204K\344\270\252\346\225\260.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\211\276\345\207\272\346\234\200\345\260\217\347\232\204K\344\270\252\346\225\260.java"
@@ -12,7 +12,6 @@
public class 找出最小的K个数 {
public static void main(String[] args) {
- Map stringObjectHashMap = new HashMap();
int[] arr = {9, 4, 15, 7, 6, 8, 87, 5, 12, 34};
// ArrayList arrayList = firstSortK(arr, 3);
// System.out.print(arrayList.toString());
@@ -47,7 +46,7 @@ public static ArrayList GetLeastNumbers_Solution1(int[] arr, int k) {
}
}
//将大顶堆输出 就是堆排序
- for(int i =a.length-1; i>=0;i--){
+ for(int i =a.length-1; i>=0;i--){
int tem=a[i];
a[i] =a[0];
a[0] =tem;
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\217\222\345\205\245\346\216\222\345\272\217.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\217\222\345\205\245\346\216\222\345\272\217.java"
index 0ab476a..625db5c 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\217\222\345\205\245\346\216\222\345\272\217.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\346\217\222\345\205\245\346\216\222\345\272\217.java"
@@ -9,7 +9,6 @@ public static void main(String[] args) {
for (int i : a) {
System.out.print(i + "\t");
}
-
}
public static int[] InsertSort(int[] arr) {
@@ -60,19 +59,18 @@ public static int[] InsertMoveSort(int[] arr) {
return arr;
}
-public static int[] InsertTest(int[] arr){
- for(int j=1;j=0 && arr[count]>tar){
- arr[count+1]=arr[count];
+ public static int[] InsertTest(int[] arr) {
+ for (int j = 1; j < arr.length; j++) {
+ int tar = arr[j];
+ int count = j - 1;
+ while (count >= 0 && arr[count] > tar) {
+ arr[count + 1] = arr[count];
count--;
}
- arr[count+1] =tar;
+ arr[count + 1] = tar;
}
-
return arr;
-}
+ }
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\351\200\211\346\213\251\346\216\222\345\272\217.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\351\200\211\346\213\251\346\216\222\345\272\217.java"
index 771a85a..8fc7850 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\351\200\211\346\213\251\346\216\222\345\272\217.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\346\216\222\345\272\217\347\256\227\346\263\225/\351\200\211\346\213\251\346\216\222\345\272\217.java"
@@ -1,23 +1,45 @@
package 排序算法;
+/*
+ * 不稳定 最好：n**2 平均：n**2 最坏：n**2
+ * */
public class 选择排序 {
public static void main(String[] args) {
int[] a = {3, 4, 2, 1, -7, 0};
- selectSort(a);
- System.out.print(a);
+ selectSortTest(a);
+
+ for (int i =0;iarr[min]?min:j;
+ for (int i = 0; i < arr.length; i++) {
+ int min = i; //找到最小的下标
+ for (int j = i + 1; j < arr.length; j++) { //自从i 之前的 肯定都是有序的 下一次找最小的值 就从 i之后开始查找
+ min = arr[j] > arr[min] ? min : j;
}
// 前面的值和最小的下标做交换
- int tmp=arr[i];
- arr[i]=arr[min];
- arr[min]=tmp;
+ int tmp = arr[i];
+ arr[i] = arr[min];
+ arr[min] = tmp;
+ }
+ return arr;
}
+
+
+ public static int[] selectSortTest(int[] arr) {
+ for(int i=0;iarr[j]?j:min;
+ }
+
+ //最小的和前面的交换
+ int tem=arr[min];
+ arr[min]=arr[i];
+ arr[i]=tem;
+ }
return arr;
}
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\345\210\206\351\273\204\351\207\221.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\345\210\206\351\273\204\351\207\221.java"
index fc2659c..0dcafbb 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\345\210\206\351\273\204\351\207\221.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\345\210\206\351\273\204\351\207\221.java"
@@ -4,42 +4,43 @@
import java.util.PriorityQueue;
/*
-* 一块金条 三个人分 【10，20，30】 表示每个人分的份数 总长度为 求和 60
-* 每切割一次 需要花费长度个硬币
-* 60先分成10和50 需要花费60个硬币 50在分成30和20 需要50个硬币 总共100硬币
-* 60先分成30和30 花费60硬币 30分成10和20 需要30个硬币 总共90硬币
-* */
-public class 分黄金 {
+ * 一块金条 三个人分 【10，20，30】 表示每个人分的份数 总长度为 求和 60
+ * 每切割一次 需要花费长度个硬币
+ * 60先分成10和50 需要花费60个硬币 50在分成30和20 需要50个硬币 总共100硬币
+ * 60先分成30和30 花费60硬币 30分成10和20 需要30个硬币 总共90硬币
+ * */
+public class 分黄金 { //这个贪心策略靠经验 但是不需要纠结证明
public static void main(String[] args) {
- int[] arr={10,20,30};
+ int[] arr = {10, 20, 30};
int i = lessMoney(arr);
System.out.println(i);
}
- public static int lessMoney(int[] arr){
+ public static int lessMoney(int[] arr) {
PriorityQueue pQ = new PriorityQueue(new MM());
- for(int i=0;i1){
- cur=pQ.poll()+pQ.poll();
- sum+=cur;
+ int sum = 0;
+ int cur = 0;
+ while (pQ.size() > 1) {
+ cur = pQ.poll() + pQ.poll();
+ sum += cur;
pQ.add(cur);
}
return sum;
}
- public static class MM implements Comparator{
+ public static class MM implements Comparator {
@Override
public int compare(Integer o1, Integer o2) {
- return o1-o2;
+ return o1 - o2;
}
-}
+ }
+
}
\ No newline at end of file
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\351\241\271\347\233\256\346\234\200\345\244\247\346\224\266\347\233\212.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\351\241\271\347\233\256\346\234\200\345\244\247\346\224\266\347\233\212.java"
new file mode 100644
index 0000000..bfca128
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\350\264\252\345\277\203/\351\241\271\347\233\256\346\234\200\345\244\247\346\224\266\347\233\212.java"
@@ -0,0 +1,66 @@
+package 贪心;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+/*
+ * 项目有成本 和利润 两个属性
+ * 一个项目只能做一次 同一时间只能做一个项目 给定初始资金
+ * 要求达到最大收益
+ * 得到结束任务后的资金是多少 （本金+利润） w+p
+ *
+ * */
+public class 项目最大收益 { //这个贪心策略靠经验 但是不需要纠结证明
+
+ public static class Node {
+ public int p; // 利润
+ public int c; //成本
+
+ public Node(int p, int c) {
+ this.p = p;
+ this.c = c;
+ }
+ }
+
+ public static class MyMinCompatator implements Comparator { //定义小根堆的优先队列 存所有的项目 维护小根堆
+
+ @Override
+ public int compare(Node o1, Node o2) {
+ return o1.c - o2.c;
+ }
+ }
+
+ public static class MyMaxCompatator implements Comparator { //定义大根堆的优先队列 存能做的项目 维护大根堆
+ @Override
+ public int compare(Node o1, Node o2) {
+ return o2.p - o1.p;
+ }
+ }
+
+ public static int getMaxProfit(int k, int w, int[] Profits, int[] Capital) {
+ Node[] nodes = new Node[Profits.length];
+ for (int i = 0; i < Profits.length; i++) {
+ nodes[i] = new Node(Profits[i], Capital[i]);
+ }
+
+ PriorityQueue maxProfitQ = new PriorityQueue<>(new MyMaxCompatator());
+ PriorityQueue minCostsQ = new PriorityQueue<>(new MyMinCompatator());
+ for (int i = 0; i < nodes.length; i++) {
+ minCostsQ.add(nodes[i]); //最小成本 项目放入 小根堆
+ }
+
+ for (int i = 0; i < k; i++) { //最多支持做k个项目
+ while (!minCostsQ.isEmpty() && minCostsQ.peek().c < w) {
+ maxProfitQ.add(nodes[i]);
+ }
+ if (maxProfitQ.isEmpty()) { //如果项目可做了 那就退出
+ return w;
+ }
+
+ w += maxProfitQ.poll().p; //取出 最大收益的项目来做
+ }
+ return w;
+ }
+}
+
+
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\200\222\345\275\222\345\222\214\345\212\250\346\200\201\350\247\204\345\210\222/READEME.md" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\200\222\345\275\222\345\222\214\345\212\250\346\200\201\350\247\204\345\210\222/READEME.md"
new file mode 100644
index 0000000..810a699
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\200\222\345\275\222\345\222\214\345\212\250\346\200\201\350\247\204\345\210\222/READEME.md"
@@ -0,0 +1,19 @@
+#### 暴力递归
+>1、把问题转化为规模缩小了的同类问题的子问题
+>
+>2、有明确的不需要继续进行递归的条件
+>
+>3、有当的到子问题的结果之后的决策过程
+>
+>4、不记录每一个问题的解
+>
+>
+#### 动态规划
+>1、从暴力递归中来
+>
+>2、将每一个子问题的解记录下来，避免重复计算
+>
+>3、把暴力递归的过程，抽象成状态表达
+>
+>4、并且存在化简状态表达，使其更加简洁的可能
+
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\200\222\345\275\222\345\222\214\345\212\250\346\200\201\350\247\204\345\210\222/coins1.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\200\222\345\275\222\345\222\214\345\212\250\346\200\201\350\247\204\345\210\222/coins1.java"
new file mode 100644
index 0000000..cd775bd
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\200\222\345\275\222\345\222\214\345\212\250\346\200\201\350\247\204\345\210\222/coins1.java"
@@ -0,0 +1,32 @@
+package 递归和动态规划;
+
+public class coins1 {
+ public static void main(String[] args) {
+ int[] arr = {5, 10, 25, 1};
+ int aim = 1000;
+ int coins = coins(arr, aim);
+ System.out.println(coins);
+ }
+
+
+ public static int coins(int[] arr, int aim) {
+
+ if (arr == null || arr.length == 0 || aim < 0) {
+ return 0;
+ }
+
+ return process1(arr, 0, aim);
+ }
+
+ private static int process1(int[] arr, int index, int aim) {
+ int res = 0;
+ if (index == arr.length) {
+ res = aim == 0 ? 1 : 0;
+ } else {
+ for (int i = 0; arr[index] * i < aim; i++) {
+ res += process1(arr, index + 1, aim - arr[index] * i);
+ }
+ }
+ return res;
+ }
+}
From a40296c7c317dfc7e84be4f6bfce5e43a365a602 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Wed, 3 Mar 2021 23:07:30 +0800
Subject: [PATCH 21/36] =?UTF-8?q?=E5=AD=97=E7=AC=A6=E4=B8=B2=E2=80=9CABBCA?=
=?UTF-8?q?DDDAC=E2=80=9C=E8=BF=9B=E8=A1=8C=E9=80=90=E6=AD=A5=E5=8E=BB?=
=?UTF-8?q?=E9=87=8D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../\351\200\220\346\255\245\345\216\273\351\207\215.java" | 7 +++++++
1 file changed, 7 insertions(+)
create mode 100644 "Intervice/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java"
diff --git "a/Intervice/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java" "b/Intervice/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java"
new file mode 100644
index 0000000..20f3e82
--- /dev/null
+++ "b/Intervice/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java"
@@ -0,0 +1,7 @@
+package com.scma.interview;
+/*
+* 对字符串“ABBCADDDAC“进行逐步去重，过程如下
+ACAAC —> ACC —> A，最后得到A
+* */
+public class 逐步去重 {
+}
From b8ea22993ef9edf1770589d8e9620928fe48ec02 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Thu, 4 Mar 2021 23:21:12 +0800
Subject: [PATCH 22/36] =?UTF-8?q?=E5=AD=97=E7=AC=A6=E4=B8=B2=E7=9B=B8?=
=?UTF-8?q?=E5=85=B3=E7=AE=97=E6=B3=95=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...6\234\200\351\225\277\345\255\220\344\270\262.java" | 10 ++++++++++
1 file changed, 10 insertions(+)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\255\227\347\254\246\344\270\262/\346\234\200\351\225\277\345\255\220\344\270\262.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\255\227\347\254\246\344\270\262/\346\234\200\351\225\277\345\255\220\344\270\262.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\255\227\347\254\246\344\270\262/\346\234\200\351\225\277\345\255\220\344\270\262.java"
new file mode 100644
index 0000000..b504f3a
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\345\255\227\347\254\246\344\270\262/\346\234\200\351\225\277\345\255\220\344\270\262.java"
@@ -0,0 +1,10 @@
+package 字符串;
+/*给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
+输入: s = "abcabcbb"
+输出: 3
+解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
+
+https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/
+* */
+public class 最长子串 {
+}
From 147290f2548690f2977d97db353a873e610d8929 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 7 Mar 2021 23:25:43 +0800
Subject: [PATCH 23/36] =?UTF-8?q?GOF23=E8=AE=BE=E8=AE=A1=E6=A8=A1=E5=BC=8F?=
=?UTF-8?q?=E7=9B=B8=E5=85=B3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
gof23/pom.xml | 12 ++++++++++++
gof23/src/main/java/READEME.md | 6 ++++++
2 files changed, 18 insertions(+)
create mode 100644 gof23/pom.xml
create mode 100644 gof23/src/main/java/READEME.md
diff --git a/gof23/pom.xml b/gof23/pom.xml
new file mode 100644
index 0000000..91942d8
--- /dev/null
+++ b/gof23/pom.xml
@@ -0,0 +1,12 @@
+
+
+ 4.0.0
+
+ org.example
+ gof23
+ 1.0-SNAPSHOT
+
+
+
\ No newline at end of file
diff --git a/gof23/src/main/java/READEME.md b/gof23/src/main/java/READEME.md
new file mode 100644
index 0000000..2de07a7
--- /dev/null
+++ b/gof23/src/main/java/READEME.md
@@ -0,0 +1,6 @@
+### 23种设计模式
+## 创建
+
+## 结构
+
+## 行为
\ No newline at end of file
From 415a8a0340fbf6d5bcec4dd8e192a6b1fd4519b5 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Mon, 8 Mar 2021 23:47:25 +0800
Subject: [PATCH 24/36] =?UTF-8?q?leetcode=E5=88=B7=E9=A2=98=E5=BC=80?=
=?UTF-8?q?=E5=A7=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../\345\277\253\344\271\220\346\225\260.java" | 5 +++++
1 file changed, 5 insertions(+)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\345\277\253\344\271\220\346\225\260.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\345\277\253\344\271\220\346\225\260.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\345\277\253\344\271\220\346\225\260.java"
new file mode 100644
index 0000000..c6d1e89
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\345\277\253\344\271\220\346\225\260.java"
@@ -0,0 +1,5 @@
+package leetcode_normal.数学数字;
+/*https://editor.csdn.net/md?articleId=114380838*/
+public class 快乐数 {
+
+}
From 2d69a8bb59399b96b04039af10f78bc3b77e79d7 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Tue, 9 Mar 2021 23:28:29 +0800
Subject: [PATCH 25/36] =?UTF-8?q?=E5=8A=A8=E6=80=81=E8=A7=84=E5=88=92-?=
=?UTF-8?q?=E6=9C=80=E5=A4=A7=E7=9A=84=E5=AD=90=E6=95=B0=E7=BB=84=E4=B9=8B?=
=?UTF-8?q?=E7=A7=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../main/java/leetcode_normal/Commons.java" | 8 +++++
.../\346\225\260\347\273\204/TwoSum.java" | 2 +-
...45\255\220\346\225\260\347\273\20476.java" | 29 +++++++++++++++++++
3 files changed, 38 insertions(+), 1 deletion(-)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/Commons.java"
rename "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum.java" => "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/TwoSum.java" (97%)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\20476.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/Commons.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/Commons.java"
new file mode 100644
index 0000000..2aaa81a
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/Commons.java"
@@ -0,0 +1,8 @@
+package leetcode_normal;
+/*
+* 公共类
+* */
+public class Commons {
+
+
+}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/TwoSum.java"
similarity index 97%
rename from "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum.java"
rename to "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/TwoSum.java"
index a5acb57..1f7adf0 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/TwoSum.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/TwoSum.java"
@@ -1,4 +1,4 @@
-package leetcode_normal;
+package leetcode_normal.数组;
import java.util.HashMap;
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\20476.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\20476.java"
new file mode 100644
index 0000000..baad274
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\20476.java"
@@ -0,0 +1,29 @@
+package leetcode_normal.数组;
+
+/*
+
+给你一个整数数组 nums ，
+请你找出数组中乘积最大的连续子数组
+（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
+* */
+public class 乘积最大子数组76 {
+
+ public static void main(String[] args) {
+ int[] nums = {2, -1, -1, -4, 2, 3};
+ int[] nums2 = {5, 6, -3, 4, -3};
+ System.out.println(maxProduct(nums));
+ }
+
+ public static int maxProduct(int[] nums) {
+ int maxF = nums[0], minF = nums[0], ans = nums[0];
+ for (int i = 1; i < nums.length; i++) {
+ int mx = maxF, mn = minF;
+ maxF = Math.max(mx * nums[i], Math.max(nums[i], mn * nums[i]));//维护最大的值
+ minF = Math.min(mn * nums[i], Math.min(nums[i], mx * nums[i]));//维护最小的值
+ ans = Math.max(maxF, ans);
+ }
+
+ return ans;
+ }
+
+}
From 905bf5925a3e969d15f4d784cdee004a4c1d8778 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Wed, 10 Mar 2021 22:46:56 +0800
Subject: [PATCH 26/36] =?UTF-8?q?=E8=B7=B3=E5=8F=B0=E9=98=B6=E9=97=AE?=
=?UTF-8?q?=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\350\267\263\345\217\260\351\230\266.java" | 51 +++++++++++++++++++
1 file changed, 51 insertions(+)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\350\267\263\345\217\260\351\230\266.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\350\267\263\345\217\260\351\230\266.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\350\267\263\345\217\260\351\230\266.java"
new file mode 100644
index 0000000..f56ee7d
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\350\267\263\345\217\260\351\230\266.java"
@@ -0,0 +1,51 @@
+package leetcode_normal.数学数字;
+
+public class 跳台阶 {
+ public static void main(String[] args) {
+ System.out.println(Jump2(6));
+ System.out.println(Jump2(6));
+ System.out.println(Jump3(6));
+
+ }
+
+
+ public static int Jump(int n) {
+ if (n == 1) {
+ return 1;
+ }
+ if (n == 2) {
+ return 2;
+ }
+ return Jump(n - 1) + Jump(n - 2);
+ }
+
+ public static int Jump2(int n) {
+ if (n == 1) {
+ return 1;
+ }
+ if (n == 2) {
+ return 2;
+ }
+ int sum = 0;
+ int one = 1, two = 2;
+ for (int i = 3; i <= n; i++) {
+ sum = one + two;
+ one = two;
+ two = sum;
+ }
+ return sum;
+ }
+
+ public static int Jump3(int n) {
+ if (n <= 2) {
+ return n;
+ }
+ int[] dp = new int[n + 1];
+ dp[1] = 1;
+ dp[2] = 2;
+ for (int i = 3; i <= n; i++) {
+ dp[i] = dp[i - 1] + dp[i - 2];
+ }
+ return dp[n];
+ }
+}
From 93cec9894d72a535d499309264140e1f74ed3296 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Wed, 10 Mar 2021 23:35:26 +0800
Subject: [PATCH 27/36] =?UTF-8?q?=E5=AF=BB=E6=89=BE=E5=B3=B0=E5=80=BC79?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...46\211\276\345\263\260\345\200\27479.java" | 45 +++++++++++++++++++
1 file changed, 45 insertions(+)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\257\273\346\211\276\345\263\260\345\200\27479.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\257\273\346\211\276\345\263\260\345\200\27479.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\257\273\346\211\276\345\263\260\345\200\27479.java"
new file mode 100644
index 0000000..657bd16
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\257\273\346\211\276\345\263\260\345\200\27479.java"
@@ -0,0 +1,45 @@
+package leetcode_normal.数组;
+
+/*
+
+峰值元素是指其值大于左右相邻值的元素。
+给你一个输入数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，
+在这种情况下，返回 任何一个峰值 所在位置即可。
+* */
+public class 寻找峰值79 {
+ public static void main(String[] args) {
+ int[] arr = {1, 2, 3, 1};
+ int peakElement = findPeakElement(arr);
+ System.out.println(peakElement);
+ System.out.println(findNum(arr));
+
+ }
+
+ public static int findPeakElement(int[] nums) {
+ if (nums.length == 0 || nums == null) {
+ return 0;
+ }
+ for (int i = 0; i < nums.length - 1; i++) {
+ if (nums[i] > nums[i + 1]) {
+ return i;
+ }
+ }
+ return nums.length - 1;
+ }
+
+ public static int findNum(int[] arr) {
+ return search(arr, 0, arr.length - 1);
+ }
+
+ public static int search(int[] arr, int l, int r) {
+ if (l == r) {
+ return l;
+ }
+ int mid = l + (r - l) / 2;
+ if (arr[mid] > arr[mid+1]) {
+ return search(arr, l, mid);
+ } else {
+ return search(arr, mid + 1, r);
+ }
+ }
+}
From f6d4094e02b007f871e0a0d4dd2754dd68b533f7 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Wed, 10 Mar 2021 23:44:13 +0800
Subject: [PATCH 28/36] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E8=AE=BE=E8=AE=A1?=
=?UTF-8?q?=E6=A8=A1=E5=BC=8F=E6=96=B0=E5=A2=9E=E4=B8=AD=E9=97=B4=E4=BB=B6?=
=?UTF-8?q?=E7=9A=84=E5=A4=87=E5=BF=98=E7=9B=AE=E5=BD=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../singletonle/DoubleCheckSingletonle.java | 2 +-
.../com/scma/gof23}/singletonle/EHan.java | 2 +-
.../com/scma/gof23}/singletonle/LHan.java | 2 +-
.../scma/gof23}/singletonle/Singleton.java | 2 +-
.../StaticInnerClassSingletonle.java | 2 +-
...25\345\210\227\346\250\241\345\274\217.md" | 0
{Intervice => juc}/pom.xml | 0
.../src/main/java/com/scma/Hash/MyTest.java | 0
.../src/main/java/com/scma/Hash/Person.java | 0
.../main/java/com/scma/Hash/TestHashSet.java | 0
.../src/main/java/com/scma/Hash/User.java | 0
.../java/com/scma/interview/RightStore.java | 2 ++
...\346\255\245\345\216\273\351\207\215.java" | 0
.../src/main/java/com/scma/juc/ABADemo.java | 0
.../com/scma/juc/AtomicReferenceDemo.java | 0
.../src/main/java/com/scma/juc/CASDemo.java | 0
.../com/scma/juc/ContainerNotSafeDemo.java | 0
.../main/java/com/scma/juc/DeadLockDemo.java | 0
.../java/com/scma/juc/MyThreadPoolDemo.java | 0
.../main/java/com/scma/juc/SemaphoreDemo.java | 0
.../main/java/com/scma/juc/SingletonDemo.java | 0
.../java/com/scma/juc/SynchronizedTest.java | 0
.../java/com/scma/juc/SynchronizedTest2.java | 0
.../java/com/scma/juc/ThreadLocalTest.java | 0
.../java/com/scma/juc/ThreadLocalTest2.java | 22 +++++++++----------
.../main/java/com/scma/juc/VolatileDemo.java | 5 +++--
.../src/main/java/com/scma/mysql/exists.java | 0
.../synchronized_test/synchronizedTest.java | 0
.../\345\244\207\345\277\230.md" | 0
.../pom.xml" | 12 ++++++++++
.../pom.xml" | 20 +++++++++++++++++
...\350\267\263\345\217\260\351\230\266.java" | 1 -
...45\255\220\346\225\260\347\273\20476.java" | 4 ++++
...46\211\276\345\263\260\345\200\27479.java" | 2 +-
...\346\225\260\347\233\270\345\212\240.java" | 18 +++++++++++++++
35 files changed, 76 insertions(+), 20 deletions(-)
rename {Intervice/src/main/java/com/scma => gof23/src/main/java/com/scma/gof23}/singletonle/DoubleCheckSingletonle.java (97%)
rename {Intervice/src/main/java/com/scma => gof23/src/main/java/com/scma/gof23}/singletonle/EHan.java (91%)
rename {Intervice/src/main/java/com/scma => gof23/src/main/java/com/scma/gof23}/singletonle/LHan.java (92%)
rename {Intervice/src/main/java/com/scma => gof23/src/main/java/com/scma/gof23}/singletonle/Singleton.java (66%)
rename {Intervice/src/main/java/com/scma => gof23/src/main/java/com/scma/gof23}/singletonle/StaticInnerClassSingletonle.java (94%)
rename "Intervice/src/main/java/com/scma/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md" => "gof23/src/main/java/com/scma/gof23/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md" (100%)
rename {Intervice => juc}/pom.xml (100%)
rename {Intervice => juc}/src/main/java/com/scma/Hash/MyTest.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/Hash/Person.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/Hash/TestHashSet.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/Hash/User.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/interview/RightStore.java (93%)
rename "Intervice/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java" => "juc/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java" (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/ABADemo.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/AtomicReferenceDemo.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/CASDemo.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/ContainerNotSafeDemo.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/DeadLockDemo.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/MyThreadPoolDemo.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/SemaphoreDemo.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/SingletonDemo.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/SynchronizedTest.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/SynchronizedTest2.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/ThreadLocalTest.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/juc/ThreadLocalTest2.java (66%)
rename {Intervice => juc}/src/main/java/com/scma/juc/VolatileDemo.java (94%)
rename {Intervice => juc}/src/main/java/com/scma/mysql/exists.java (100%)
rename {Intervice => juc}/src/main/java/com/scma/synchronized_test/synchronizedTest.java (100%)
delete mode 100644 "\344\270\200\347\253\231\345\274\217/\345\244\207\345\277\230.md"
create mode 100644 "\344\270\255\351\227\264\344\273\266/pom.xml"
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\223\276\350\241\250/\344\270\244\346\225\260\347\233\270\345\212\240.java"
diff --git a/Intervice/src/main/java/com/scma/singletonle/DoubleCheckSingletonle.java b/gof23/src/main/java/com/scma/gof23/singletonle/DoubleCheckSingletonle.java
similarity index 97%
rename from Intervice/src/main/java/com/scma/singletonle/DoubleCheckSingletonle.java
rename to gof23/src/main/java/com/scma/gof23/singletonle/DoubleCheckSingletonle.java
index 05472b0..2a3243a 100644
--- a/Intervice/src/main/java/com/scma/singletonle/DoubleCheckSingletonle.java
+++ b/gof23/src/main/java/com/scma/gof23/singletonle/DoubleCheckSingletonle.java
@@ -1,4 +1,4 @@
-package com.scma.singletonle;
+package com.scma.gof23.singletonle;
/*
diff --git a/Intervice/src/main/java/com/scma/singletonle/EHan.java b/gof23/src/main/java/com/scma/gof23/singletonle/EHan.java
similarity index 91%
rename from Intervice/src/main/java/com/scma/singletonle/EHan.java
rename to gof23/src/main/java/com/scma/gof23/singletonle/EHan.java
index 98dbcd7..045cabb 100644
--- a/Intervice/src/main/java/com/scma/singletonle/EHan.java
+++ b/gof23/src/main/java/com/scma/gof23/singletonle/EHan.java
@@ -1,4 +1,4 @@
-package com.scma.singletonle;
+package com.scma.gof23.singletonle;
/*
* 从名字上也很好理解，就是“比较勤”，实例在初始化的时候就已经建好了，不
* 管你有没有用到，都先建好了再说。
diff --git a/Intervice/src/main/java/com/scma/singletonle/LHan.java b/gof23/src/main/java/com/scma/gof23/singletonle/LHan.java
similarity index 92%
rename from Intervice/src/main/java/com/scma/singletonle/LHan.java
rename to gof23/src/main/java/com/scma/gof23/singletonle/LHan.java
index bfec495..b15639e 100644
--- a/Intervice/src/main/java/com/scma/singletonle/LHan.java
+++ b/gof23/src/main/java/com/scma/gof23/singletonle/LHan.java
@@ -1,4 +1,4 @@
-package com.scma.singletonle;
+package com.scma.gof23.singletonle;
/*
* 就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，
* 如果有则返回，没有则新建。有线程安全和线程不安全两种写法，
diff --git a/Intervice/src/main/java/com/scma/singletonle/Singleton.java b/gof23/src/main/java/com/scma/gof23/singletonle/Singleton.java
similarity index 66%
rename from Intervice/src/main/java/com/scma/singletonle/Singleton.java
rename to gof23/src/main/java/com/scma/gof23/singletonle/Singleton.java
index b4da6b9..d5e4af1 100644
--- a/Intervice/src/main/java/com/scma/singletonle/Singleton.java
+++ b/gof23/src/main/java/com/scma/gof23/singletonle/Singleton.java
@@ -1,4 +1,4 @@
-package com.scma.singletonle;
+package com.scma.gof23.singletonle;
public enum Singleton {
INSTANCE;
diff --git a/Intervice/src/main/java/com/scma/singletonle/StaticInnerClassSingletonle.java b/gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java
similarity index 94%
rename from Intervice/src/main/java/com/scma/singletonle/StaticInnerClassSingletonle.java
rename to gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java
index ffa6e5b..b336360 100644
--- a/Intervice/src/main/java/com/scma/singletonle/StaticInnerClassSingletonle.java
+++ b/gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java
@@ -1,4 +1,4 @@
-package com.scma.singletonle;
+package com.scma.gof23.singletonle;
/*
* 效果类似双检锁，但实现更简单。
* 但这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用
diff --git "a/Intervice/src/main/java/com/scma/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md" "b/gof23/src/main/java/com/scma/gof23/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md"
similarity index 100%
rename from "Intervice/src/main/java/com/scma/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md"
rename to "gof23/src/main/java/com/scma/gof23/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md"
diff --git a/Intervice/pom.xml b/juc/pom.xml
similarity index 100%
rename from Intervice/pom.xml
rename to juc/pom.xml
diff --git a/Intervice/src/main/java/com/scma/Hash/MyTest.java b/juc/src/main/java/com/scma/Hash/MyTest.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/Hash/MyTest.java
rename to juc/src/main/java/com/scma/Hash/MyTest.java
diff --git a/Intervice/src/main/java/com/scma/Hash/Person.java b/juc/src/main/java/com/scma/Hash/Person.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/Hash/Person.java
rename to juc/src/main/java/com/scma/Hash/Person.java
diff --git a/Intervice/src/main/java/com/scma/Hash/TestHashSet.java b/juc/src/main/java/com/scma/Hash/TestHashSet.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/Hash/TestHashSet.java
rename to juc/src/main/java/com/scma/Hash/TestHashSet.java
diff --git a/Intervice/src/main/java/com/scma/Hash/User.java b/juc/src/main/java/com/scma/Hash/User.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/Hash/User.java
rename to juc/src/main/java/com/scma/Hash/User.java
diff --git a/Intervice/src/main/java/com/scma/interview/RightStore.java b/juc/src/main/java/com/scma/interview/RightStore.java
similarity index 93%
rename from Intervice/src/main/java/com/scma/interview/RightStore.java
rename to juc/src/main/java/com/scma/interview/RightStore.java
index b6c2cd6..7e55f6a 100644
--- a/Intervice/src/main/java/com/scma/interview/RightStore.java
+++ b/juc/src/main/java/com/scma/interview/RightStore.java
@@ -20,6 +20,8 @@ public boolean getRight(int position){
// 该方法存储或清除传入的权限，如果value为true，存储传入的权限，否则清除该权限。
// position传入的权限的位置
public void setRight(int position, boolean value){
+ StringBuilder ste=new StringBuilder("00");
+ ste.capacity();
StringBuilder stringBuilder = new StringBuilder(rightString);
if(value){
stringBuilder.replace(position-1,position,"1");
diff --git "a/Intervice/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java" "b/juc/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java"
similarity index 100%
rename from "Intervice/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java"
rename to "juc/src/main/java/com/scma/interview/\351\200\220\346\255\245\345\216\273\351\207\215.java"
diff --git a/Intervice/src/main/java/com/scma/juc/ABADemo.java b/juc/src/main/java/com/scma/juc/ABADemo.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/ABADemo.java
rename to juc/src/main/java/com/scma/juc/ABADemo.java
diff --git a/Intervice/src/main/java/com/scma/juc/AtomicReferenceDemo.java b/juc/src/main/java/com/scma/juc/AtomicReferenceDemo.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/AtomicReferenceDemo.java
rename to juc/src/main/java/com/scma/juc/AtomicReferenceDemo.java
diff --git a/Intervice/src/main/java/com/scma/juc/CASDemo.java b/juc/src/main/java/com/scma/juc/CASDemo.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/CASDemo.java
rename to juc/src/main/java/com/scma/juc/CASDemo.java
diff --git a/Intervice/src/main/java/com/scma/juc/ContainerNotSafeDemo.java b/juc/src/main/java/com/scma/juc/ContainerNotSafeDemo.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/ContainerNotSafeDemo.java
rename to juc/src/main/java/com/scma/juc/ContainerNotSafeDemo.java
diff --git a/Intervice/src/main/java/com/scma/juc/DeadLockDemo.java b/juc/src/main/java/com/scma/juc/DeadLockDemo.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/DeadLockDemo.java
rename to juc/src/main/java/com/scma/juc/DeadLockDemo.java
diff --git a/Intervice/src/main/java/com/scma/juc/MyThreadPoolDemo.java b/juc/src/main/java/com/scma/juc/MyThreadPoolDemo.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/MyThreadPoolDemo.java
rename to juc/src/main/java/com/scma/juc/MyThreadPoolDemo.java
diff --git a/Intervice/src/main/java/com/scma/juc/SemaphoreDemo.java b/juc/src/main/java/com/scma/juc/SemaphoreDemo.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/SemaphoreDemo.java
rename to juc/src/main/java/com/scma/juc/SemaphoreDemo.java
diff --git a/Intervice/src/main/java/com/scma/juc/SingletonDemo.java b/juc/src/main/java/com/scma/juc/SingletonDemo.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/SingletonDemo.java
rename to juc/src/main/java/com/scma/juc/SingletonDemo.java
diff --git a/Intervice/src/main/java/com/scma/juc/SynchronizedTest.java b/juc/src/main/java/com/scma/juc/SynchronizedTest.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/SynchronizedTest.java
rename to juc/src/main/java/com/scma/juc/SynchronizedTest.java
diff --git a/Intervice/src/main/java/com/scma/juc/SynchronizedTest2.java b/juc/src/main/java/com/scma/juc/SynchronizedTest2.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/SynchronizedTest2.java
rename to juc/src/main/java/com/scma/juc/SynchronizedTest2.java
diff --git a/Intervice/src/main/java/com/scma/juc/ThreadLocalTest.java b/juc/src/main/java/com/scma/juc/ThreadLocalTest.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/juc/ThreadLocalTest.java
rename to juc/src/main/java/com/scma/juc/ThreadLocalTest.java
diff --git a/Intervice/src/main/java/com/scma/juc/ThreadLocalTest2.java b/juc/src/main/java/com/scma/juc/ThreadLocalTest2.java
similarity index 66%
rename from Intervice/src/main/java/com/scma/juc/ThreadLocalTest2.java
rename to juc/src/main/java/com/scma/juc/ThreadLocalTest2.java
index 4e91901..a637069 100644
--- a/Intervice/src/main/java/com/scma/juc/ThreadLocalTest2.java
+++ b/juc/src/main/java/com/scma/juc/ThreadLocalTest2.java
@@ -7,32 +7,32 @@
import java.util.concurrent.TimeUnit;
public class ThreadLocalTest2 {
- public static int addnum=0;//原来写法
-public static ThreadLocal number=new ThreadLocal();
- public static int add10(int num){
- addnum=num;//原来写法
+ public static int addnum = 0;//原来写法
+ public static ThreadLocal number = new ThreadLocal();
+
+ public static int add10(int num) {
+ addnum = num;//原来写法
number.set(num);
try {
TimeUnit.SECONDS.sleep(1); //这里线程都在这里休眠 但是num的值都是同一个 这样 一组线程的结果是相同的
- // 因此需用 Threadlocal来处理 让这个值变成线程私有的 即可
- }catch (Exception e){
+ // 因此需用 Threadlocal来处理 让这个值变成线程私有的 即可
+ } catch (Exception e) {
e.printStackTrace();
}
- int m=number.get()+10;
+ int m = number.get() + 10;
// return addnum+10; //原来写法
return m;
}
-
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
- for(int i=0;i<20;i++){
- final int num=i;
+ for (int i = 0; i < 20; i++) {
+ final int num = i;
executorService.execute(new Runnable() {
@Override
public void run() {
- System.out.println(num + " " + ThreadLocalTest2.add10(num)+"线程名称："+Thread.currentThread().getId());
+ System.out.println(num + " " + ThreadLocalTest2.add10(num) + "线程名称：" + Thread.currentThread().getId());
// System.out.println(Thread.currentThread().getId());
}
diff --git a/Intervice/src/main/java/com/scma/juc/VolatileDemo.java b/juc/src/main/java/com/scma/juc/VolatileDemo.java
similarity index 94%
rename from Intervice/src/main/java/com/scma/juc/VolatileDemo.java
rename to juc/src/main/java/com/scma/juc/VolatileDemo.java
index b1e25f6..f817e31 100644
--- a/Intervice/src/main/java/com/scma/juc/VolatileDemo.java
+++ b/juc/src/main/java/com/scma/juc/VolatileDemo.java
@@ -30,6 +30,7 @@ public void run() {
System.out.println(Thread.currentThread().getName() + "\t come in");
try {
+// Thread.sleep(20);
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
@@ -50,8 +51,8 @@ public void run() {
}
class MyData {
- int number = 0;
-// volatile int number = 0;
+// int number = 0;
+ volatile int number = 0;
public void add() {
this.number = 60;
diff --git a/Intervice/src/main/java/com/scma/mysql/exists.java b/juc/src/main/java/com/scma/mysql/exists.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/mysql/exists.java
rename to juc/src/main/java/com/scma/mysql/exists.java
diff --git a/Intervice/src/main/java/com/scma/synchronized_test/synchronizedTest.java b/juc/src/main/java/com/scma/synchronized_test/synchronizedTest.java
similarity index 100%
rename from Intervice/src/main/java/com/scma/synchronized_test/synchronizedTest.java
rename to juc/src/main/java/com/scma/synchronized_test/synchronizedTest.java
diff --git "a/\344\270\200\347\253\231\345\274\217/\345\244\207\345\277\230.md" "b/\344\270\200\347\253\231\345\274\217/\345\244\207\345\277\230.md"
deleted file mode 100644
index e69de29..0000000
diff --git "a/\344\270\255\351\227\264\344\273\266/pom.xml" "b/\344\270\255\351\227\264\344\273\266/pom.xml"
new file mode 100644
index 0000000..ba7ef16
--- /dev/null
+++ "b/\344\270\255\351\227\264\344\273\266/pom.xml"
@@ -0,0 +1,12 @@
+
+
+ 4.0.0
+
+ org.example
+ 中间件
+ 1.0-SNAPSHOT
+
+
+
\ No newline at end of file
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/pom.xml" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/pom.xml"
index 1259c66..d3c4956 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/pom.xml"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/pom.xml"
@@ -7,6 +7,26 @@
org.example
算法数据结构
1.0-SNAPSHOT
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+ 8
+ 8
+
+
+
+
+
+
+ org.jetbrains
+ annotations
+ RELEASE
+ compile
+
+
\ No newline at end of file
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\350\267\263\345\217\260\351\230\266.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\350\267\263\345\217\260\351\230\266.java"
index f56ee7d..b4f8fb9 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\350\267\263\345\217\260\351\230\266.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\345\255\246\346\225\260\345\255\227/\350\267\263\345\217\260\351\230\266.java"
@@ -5,7 +5,6 @@ public static void main(String[] args) {
System.out.println(Jump2(6));
System.out.println(Jump2(6));
System.out.println(Jump3(6));
-
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\20476.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\20476.java"
index baad274..a03fcaf 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\20476.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\20476.java"
@@ -5,11 +5,14 @@
给你一个整数数组 nums ，
请你找出数组中乘积最大的连续子数组
（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
+
+https://leetcode-cn.com/problems/maximum-product-subarray/submissions/
* */
public class 乘积最大子数组76 {
public static void main(String[] args) {
int[] nums = {2, -1, -1, -4, 2, 3};
+ int[] my ={4,0,3,2};
int[] nums2 = {5, 6, -3, 4, -3};
System.out.println(maxProduct(nums));
}
@@ -18,6 +21,7 @@ public static int maxProduct(int[] nums) {
int maxF = nums[0], minF = nums[0], ans = nums[0];
for (int i = 1; i < nums.length; i++) {
int mx = maxF, mn = minF;
+// maxF = Math.max(maxF * nums[i], nums[i]); //不考虑负数情况
maxF = Math.max(mx * nums[i], Math.max(nums[i], mn * nums[i]));//维护最大的值
minF = Math.min(mn * nums[i], Math.min(nums[i], mx * nums[i]));//维护最小的值
ans = Math.max(maxF, ans);
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\257\273\346\211\276\345\263\260\345\200\27479.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\257\273\346\211\276\345\263\260\345\200\27479.java"
index 657bd16..4d779d6 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\257\273\346\211\276\345\263\260\345\200\27479.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\257\273\346\211\276\345\263\260\345\200\27479.java"
@@ -36,7 +36,7 @@ public static int search(int[] arr, int l, int r) {
return l;
}
int mid = l + (r - l) / 2;
- if (arr[mid] > arr[mid+1]) {
+ if (arr[mid] > arr[mid+1]) { //表示下降 那么峰值 一定在前面
return search(arr, l, mid);
} else {
return search(arr, mid + 1, r);
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\223\276\350\241\250/\344\270\244\346\225\260\347\233\270\345\212\240.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\223\276\350\241\250/\344\270\244\346\225\260\347\233\270\345\212\240.java"
new file mode 100644
index 0000000..ad04537
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\223\276\350\241\250/\344\270\244\346\225\260\347\233\270\345\212\240.java"
@@ -0,0 +1,18 @@
+package 链表;
+/*
+* 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
+
+请你将两个数相加，并以相同形式返回一个表示和的链表。
+
+你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/add-two-numbers
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+*
+* 输入：l1 = [2,4,3], l2 = [5,6,4]
+输出：[7,0,8]
+解释：342 + 465 = 807.
+* */
+public class 两数相加 {
+}
From 8171f2279c4b6da0fe238430e2c1c8d6c0f94239 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 14 Mar 2021 17:38:38 +0800
Subject: [PATCH 29/36] =?UTF-8?q?=E6=95=B0=E6=8D=AE=E7=BB=93=E6=9E=84?=
=?UTF-8?q?=E7=AE=97=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../StaticInnerClassSingletonle.java | 1 +
...45\262\233\351\227\256\351\242\23088.java" | 70 +++++++++++++++++++
...45\244\247\345\205\203\347\264\24092.java" | 46 ++++++++++++
...\345\215\260\351\223\276\350\241\250.java" | 28 ++++----
4 files changed, 133 insertions(+), 12 deletions(-)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\262\233\351\227\256\351\242\23088.java"
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\24092.java"
diff --git a/gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java b/gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java
index b336360..1ab8bfb 100644
--- a/gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java
+++ b/gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java
@@ -15,6 +15,7 @@ private static StaticInnerClassSingletonle getInstance() {
// 静态内部类
private static class SingletonleHolder {
+
private static final StaticInnerClassSingletonle INSTANCE = new StaticInnerClassSingletonle();
}
}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\262\233\351\227\256\351\242\23088.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\262\233\351\227\256\351\242\23088.java"
new file mode 100644
index 0000000..bd783fd
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\345\262\233\351\227\256\351\242\23088.java"
@@ -0,0 +1,70 @@
+package leetcode_normal.数组;
+
+/*
+ * 一个矩阵中只有0和1 每个位置都可以和自己的上下左右 四个位置相连
+ * 如果一片1 连在一起，这个部分叫做一个岛 求一个矩阵中有几个岛
+ *
+ * 举例
+ * 0 0 1 0 1 0
+ * 1 1 1 0 1 0
+ * 1 0 0 1 0 0
+ * 0 0 0 0 0 0
+ *
+ * 这个矩阵中有三个岛
+ * */
+//并查集 求法 多CPU处理 并行
+/*
+将二维数组区域划分成多个区域 对每个区域求感染区域 将区域特殊标做标记 不同区域标记不同
+多个区域算出来有几个岛之后 对边界进行合并 相同标记的合并只保留一个区域
+多CUP并行处理，能加快计算速度
+* */
+
+
+//使用常规解法 不使用并查集
+public class 岛问题88 {
+ public static void main(String[] args) {
+ String AA="12432432";
+ String[] split = AA.split("");
+//boolean Boolean
+ char[] chars = AA.toCharArray();
+ System.out.println(chars);
+ int[][] m1 = {
+ {0, 0, 1, 0, 1, 0},
+ {1, 1, 1, 0, 1, 0},
+ {1, 0, 0, 1, 0, 0},
+ {0, 0, 0, 0, 0, 0}
+ };
+ int alent = alent(m1);
+ System.out.println(alent);
+ }
+
+ public static int alent(int[][] m) {
+ if (m.length == 0) {
+ return 0;
+ }
+ int M = m.length;
+ int N = m[0].length;
+ int res = 0;
+ for (int i = 0; i < M; i++) {
+ for (int j = 0; j < N; j++) { //循环所有
+ if (m[i][j] == 1) { //如果有岛屿 那么数量++ 然后将这一片都给感染掉 下次遍历的时候 就不进行岛屿数量++操作了
+ res++;
+ infect(m, i, j, M, N); //感染函数
+ }
+ }
+ }
+ return res;
+ }
+
+ private static void infect(int[][] m, int i, int j, int M, int N) {
+ if (i < 0 || i >= M || j < 0 || j >= N || m[i][j] != 1) {
+ return;
+ }
+ m[i][j] = 2;
+ infect(m, i + 1, j, M, N);
+ infect(m, i - 1, j, M, N);
+ infect(m, i, j + 1, M, N);
+ infect(m, i, j - 1, M, N);
+ }
+
+}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\24092.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\24092.java"
new file mode 100644
index 0000000..d42de2e
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\24092.java"
@@ -0,0 +1,46 @@
+package leetcode_normal.数组;
+
+/*
+ * 在未排序的数组中找到第 k 个最大的元素。请注意，
+ * 你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素
+ * */
+public class 数组中的第K个最大元素92 {
+ public static void main(String[] args) {
+ int[] arr = {3,2,3,1,2,4,5,5,6};
+// findK(arr,2);
+ System.out.println(findK(arr,4));
+
+ }
+// public int findKthLargest(int[] nums, int k) {
+// QuikSort(nums, 0, nums.length - 1);
+// return nums[nums.length-k];
+// }
+ public static int findK(int[] arr, int k) {
+ QuikSort(arr, 0, arr.length - 1);
+ return arr[arr.length-k];
+ }
+
+
+ public static void QuikSort(int[] arr, int low, int high) {
+ if (arr.length == 0) {
+ return;
+ }
+ int l = low;
+ int r = high;
+ if(r l) {
+ while (r > l && arr[r] >= tar) {
+ r--;
+ }
+ arr[l] = arr[r];
+ while (r > l && arr[l] < tar) {
+ l++;
+ }
+ arr[r] = arr[l];
+ }
+ arr[l] = tar;
+ QuikSort(arr, low, l - 1);
+ QuikSort(arr, l + 1, high);
+ }
+}
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\223\276\350\241\250/\351\200\206\345\272\217\346\211\223\345\215\260\351\223\276\350\241\250.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\223\276\350\241\250/\351\200\206\345\272\217\346\211\223\345\215\260\351\223\276\350\241\250.java"
index 7e4e2ff..8c74fda 100644
--- "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\223\276\350\241\250/\351\200\206\345\272\217\346\211\223\345\215\260\351\223\276\350\241\250.java"
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/\351\223\276\350\241\250/\351\200\206\345\272\217\346\211\223\345\215\260\351\223\276\350\241\250.java"
@@ -3,25 +3,27 @@
import java.util.ArrayList;
import java.util.List;
-public class 逆序打印链表 {
+public class 逆序打印链表 {
public static void main(String[] args) {
ListNode head = new ListNode(1);
- head.next=new ListNode(4);
- head.next.next=new ListNode(3);
+ head.next = new ListNode(4);
+ head.next.next = new ListNode(3);
List integers = printListNode(head);
System.out.print(integers.toString());
ListNode listNode = reverseOrderListNode(head);
System.out.print(printListNode(listNode).toString());
}
- /**单链表逆序方法*/
- public static ListNode reverseOrderListNode(ListNode head){
- if(head==null) {
+ /**
+ * 单链表逆序方法
+ */
+ public static ListNode reverseOrderListNode(ListNode head) {
+ if (head == null) {
return null;
}
// 1 4 3 ====> 3 4 1
ListNode p = new ListNode(0);
- while(head!=null){
+ while (head != null) {
ListNode tmp = head.next;// 4 3
head.next = p.next; //
p.next = head;// null
@@ -31,12 +33,14 @@ public static ListNode reverseOrderListNode(ListNode head){
}
- /**打印链表公共方法*/
- public static List printListNode(ListNode head){
- List list = new ArrayList();
- while(head!=null){
+ /**
+ * 打印链表公共方法
+ */
+ public static List printListNode(ListNode head) {
+ List list = new ArrayList();
+ while (head != null) {
list.add(head.val);
- head=head.next;
+ head = head.next;
}
return list;
}
From 67d48bfef4f6483e50435ef29c0685f22b2d8daa Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 14 Mar 2021 19:17:25 +0800
Subject: [PATCH 30/36] =?UTF-8?q?=E8=AE=BE=E8=AE=A1=E6=A8=A1=E5=BC=8F?=
=?UTF-8?q?=E6=A6=82=E8=A7=88=E3=80=81=E9=9D=A2=E5=90=91=E5=AF=B9=E8=B1=A1?=
=?UTF-8?q?=E4=B8=83=E5=A4=A7=E5=8E=9F=E5=88=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
gof23/src/main/java/READEME.md | 44 +++++++++++++++++++++++++++++++---
1 file changed, 41 insertions(+), 3 deletions(-)
diff --git a/gof23/src/main/java/READEME.md b/gof23/src/main/java/READEME.md
index 2de07a7..c54dc87 100644
--- a/gof23/src/main/java/READEME.md
+++ b/gof23/src/main/java/READEME.md
@@ -1,6 +1,44 @@
### 23种设计模式
-## 创建
+```java
-## 结构
+设计模式是前辈们对代码开发的经验总结，是解决问题
+的一系列>套路，它不是语法规定，而是一套用来提高代
+码可复用性、可维护性、可读性、稳健性以及安全性的
+解决方案。
-## 行为
\ No newline at end of file
+```
+### 一种思维、一种态度、一种进步
+>
+## 创建型模式
+```java
+单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
+```
+
+## 结构型模式
+```java
+适配器模式、桥接模式、装饰模式、组合模式、
+外观模式、享元模式、代理模式
+```
+
+## 行为型模式
+```java
+模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式
+备忘录模式、解释器模式、状态模式、策略模式、职责链模式、
+访问者模式
+
+```
+
+### 面向对象七大原则
+> 开闭原则 ：对扩展开发、对修改关闭
+
+>里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立
+
+>依赖倒置原则： 要面向接口编程，不要面向实现编程
+
+>单一职责原则：控制类的粒度大小、将对象解耦、提高内聚性
+
+>接口隔离原则：要为各个类建立它们需要的专用接口
+
+>迪米特法则：只与你的直接朋友交谈，不与陌生人说话
+
+>合成服用原则：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现
\ No newline at end of file
From 72f05043a6bf50d2d07ac7d51519e051e297d3f7 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 14 Mar 2021 20:25:00 +0800
Subject: [PATCH 31/36] =?UTF-8?q?=E5=B7=A5=E5=8E=82=E6=A8=A1=E5=BC=8F?=
=?UTF-8?q?=E3=80=81=E6=8A=BD=E8=B1=A1=E5=B7=A5=E5=8E=82=E6=A8=A1=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../java/com/scma/gof23/factory/READEME.md | 16 +++++++++++++
.../Car.java" | 5 ++++
.../CarFactory.java" | 6 +++++
.../Consumer.java" | 15 ++++++++++++
.../TesLa.java" | 8 +++++++
.../TesLaFactory.java" | 8 +++++++
.../WuLing.java" | 8 +++++++
.../WuLingFactory.java" | 8 +++++++
.../Client.java" | 14 +++++++++++
.../HuaWeiFactory.java" | 15 ++++++++++++
.../HuaWeiPhone.java" | 23 ++++++++++++++++++
.../HuaWeiRouter.java" | 23 ++++++++++++++++++
.../IPhoneProduct.java" | 14 +++++++++++
.../IProductFactory.java" | 10 ++++++++
.../IRouterProduct.java" | 11 +++++++++
.../XiaoMiPhone.java" | 24 +++++++++++++++++++
.../XiaoMiRouter.java" | 23 ++++++++++++++++++
.../XiaomiFactory.java" | 13 ++++++++++
.../Car.java" | 5 ++++
.../CarFactory.java" | 16 +++++++++++++
.../Consumer.java" | 18 ++++++++++++++
.../TesLa.java" | 8 +++++++
.../WuLing.java" | 8 +++++++
23 files changed, 299 insertions(+)
create mode 100644 gof23/src/main/java/com/scma/gof23/factory/READEME.md
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java"
diff --git a/gof23/src/main/java/com/scma/gof23/factory/READEME.md b/gof23/src/main/java/com/scma/gof23/factory/READEME.md
new file mode 100644
index 0000000..fbee85e
--- /dev/null
+++ b/gof23/src/main/java/com/scma/gof23/factory/READEME.md
@@ -0,0 +1,16 @@
+#### 简单工厂模式（静态工厂模式）
+> 虽然某种程度上不符合设计原则，但实际使用最多
+>
+#### 工厂方法模式
+> 不修改已有类的前提下，通过新增工厂类实现拓展
+>
+
+#### 抽象工厂模式
+> 不可以增加产品，可以增加产品族
+>
+
+### 应用场景
+1、JDK中Calendar的getInstance方法
+2、JDBC中Connection对象的获取
+3、Spring中IOC容器创建管理Bean对象
+4、反射中Class对象的newInstance方法
\ No newline at end of file
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java" "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java"
new file mode 100644
index 0000000..c2df137
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java"
@@ -0,0 +1,5 @@
+package com.scma.gof23.factory.工厂方法模式;
+
+public interface Car {
+ public void name();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java" "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java"
new file mode 100644
index 0000000..bc9fff6
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java"
@@ -0,0 +1,6 @@
+package com.scma.gof23.factory.工厂方法模式;
+
+/*工厂方法模式*/
+public interface CarFactory {
+ Car getCar();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java" "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java"
new file mode 100644
index 0000000..0adac82
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java"
@@ -0,0 +1,15 @@
+package com.scma.gof23.factory.工厂方法模式;
+
+import com.scma.gof23.factory.简单工厂模式.CarFactory;
+
+/*不改变原来的代码 新增一个车 直接新增一个工厂类 方便扩展*/
+public class Consumer {
+ public static void main(String[] args) {
+ Car car = new WuLingFactory().getCar();
+ Car car1 = new TesLaFactory().getCar();
+ car.name();
+ car1.name();
+ }
+
+
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java" "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java"
new file mode 100644
index 0000000..b8a8197
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java"
@@ -0,0 +1,8 @@
+package com.scma.gof23.factory.工厂方法模式;
+
+public class TesLa implements Car {
+ @Override
+ public void name() {
+ System.out.println("特斯拉");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java" "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java"
new file mode 100644
index 0000000..02a9945
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java"
@@ -0,0 +1,8 @@
+package com.scma.gof23.factory.工厂方法模式;
+
+public class TesLaFactory implements CarFactory {
+ @Override
+ public Car getCar() {
+ return new TesLa();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java" "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java"
new file mode 100644
index 0000000..d8d5cb8
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java"
@@ -0,0 +1,8 @@
+package com.scma.gof23.factory.工厂方法模式;
+
+public class WuLing implements Car {
+ @Override
+ public void name() {
+ System.out.println("五菱宏光");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java" "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java"
new file mode 100644
index 0000000..a121543
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java"
@@ -0,0 +1,8 @@
+package com.scma.gof23.factory.工厂方法模式;
+
+public class WuLingFactory implements CarFactory {
+ @Override
+ public Car getCar() {
+ return new WuLing();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java"
new file mode 100644
index 0000000..a55de06
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java"
@@ -0,0 +1,14 @@
+package com.scma.gof23.factory.抽象工厂模式;
+
+public class Client {
+ public static void main(String[] args) {
+ System.out.println("===========小米系列==========");
+ XiaomiFactory xiaomiFactory = new XiaomiFactory();
+
+ IPhoneProduct iPhoneProduct = xiaomiFactory.iphoneProduct();
+ iPhoneProduct.callup();
+
+ IRouterProduct iRouterProduct = xiaomiFactory.routerProduct();
+ iRouterProduct.openwifi();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java"
new file mode 100644
index 0000000..1fc5b7c
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java"
@@ -0,0 +1,15 @@
+package com.scma.gof23.factory.抽象工厂模式;
+
+public class HuaWeiFactory implements IProductFactory {
+ @Override
+ public IPhoneProduct iphoneProduct() {
+
+ return new HuaWeiPhone();
+ }
+
+ @Override
+ public IRouterProduct routerProduct() {
+
+ return new HuaWeiRouter();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java"
new file mode 100644
index 0000000..9fa239c
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java"
@@ -0,0 +1,23 @@
+package com.scma.gof23.factory.抽象工厂模式;
+/*华为手机*/
+public class HuaWeiPhone implements IPhoneProduct {
+ @Override
+ public void start() {
+ System.out.println("开启华为手机");
+ }
+
+ @Override
+ public void shutdown() {
+ System.out.println("关闭华为手机");
+ }
+
+ @Override
+ public void callup() {
+ System.out.println("华为手机callup");
+ }
+
+ @Override
+ public void sentSms() {
+ System.out.println("华为手机sentSms");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java"
new file mode 100644
index 0000000..8fff2bc
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java"
@@ -0,0 +1,23 @@
+package com.scma.gof23.factory.抽象工厂模式;
+/*华为路由器*/
+public class HuaWeiRouter implements IRouterProduct {
+ @Override
+ public void start() {
+ System.out.println("开启华为路由器");
+ }
+
+ @Override
+ public void shutdown() {
+ System.out.println("开启华为路由器");
+ }
+
+ @Override
+ public void openwifi() {
+ System.out.println("华为路由器openwifi");
+ }
+
+ @Override
+ public void sentSms() {
+ System.out.println("华为路由器sentSms");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java"
new file mode 100644
index 0000000..8ceeef8
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java"
@@ -0,0 +1,14 @@
+package com.scma.gof23.factory.抽象工厂模式;
+
+/*手机产品接口
+ * */
+public interface IPhoneProduct {
+ void start();
+
+ void shutdown();
+
+ void callup();
+
+ void sentSms();
+
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java"
new file mode 100644
index 0000000..893c26a
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java"
@@ -0,0 +1,10 @@
+package com.scma.gof23.factory.抽象工厂模式;
+
+//抽象产品工厂 （抽象的 抽象）
+public interface IProductFactory {
+ //生产手机
+ IPhoneProduct iphoneProduct();
+
+ //生产路由器
+ IRouterProduct routerProduct();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java"
new file mode 100644
index 0000000..1440286
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java"
@@ -0,0 +1,11 @@
+package com.scma.gof23.factory.抽象工厂模式;
+/*路由器产品接口*/
+public interface IRouterProduct {
+ void start();
+
+ void shutdown();
+
+ void openwifi();
+
+ void sentSms();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java"
new file mode 100644
index 0000000..093b58e
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java"
@@ -0,0 +1,24 @@
+package com.scma.gof23.factory.抽象工厂模式;
+/*
+* 小米手机*/
+public class XiaoMiPhone implements IPhoneProduct {
+ @Override
+ public void start() {
+ System.out.println("开启小米手机");
+ }
+
+ @Override
+ public void shutdown() {
+ System.out.println("关闭小米手机");
+ }
+
+ @Override
+ public void callup() {
+ System.out.println("小米手机callup");
+ }
+
+ @Override
+ public void sentSms() {
+ System.out.println("米手机sentSms");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java"
new file mode 100644
index 0000000..c2454d4
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java"
@@ -0,0 +1,23 @@
+package com.scma.gof23.factory.抽象工厂模式;
+/*小米路由器*/
+public class XiaoMiRouter implements IRouterProduct {
+ @Override
+ public void start() {
+ System.out.println("开启小米路由器");
+ }
+
+ @Override
+ public void shutdown() {
+ System.out.println("开启小米路由器");
+ }
+
+ @Override
+ public void openwifi() {
+ System.out.println("小米路由器openwifi");
+ }
+
+ @Override
+ public void sentSms() {
+ System.out.println("小米路由器sentSms");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java" "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java"
new file mode 100644
index 0000000..d32aeed
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java"
@@ -0,0 +1,13 @@
+package com.scma.gof23.factory.抽象工厂模式;
+
+public class XiaomiFactory implements IProductFactory {
+ @Override
+ public IPhoneProduct iphoneProduct() {
+ return new XiaoMiPhone();
+ }
+
+ @Override
+ public IRouterProduct routerProduct() {
+ return new XiaoMiRouter();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java" "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java"
new file mode 100644
index 0000000..051f317
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java"
@@ -0,0 +1,5 @@
+package com.scma.gof23.factory.简单工厂模式;
+
+public interface Car {
+ public void name();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java" "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java"
new file mode 100644
index 0000000..9d18422
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java"
@@ -0,0 +1,16 @@
+package com.scma.gof23.factory.简单工厂模式;
+
+/*简单车工厂 （静态工厂模式） 如果有新车品牌 会改变工厂代码
+
+--不满足开闭原则*/
+public class CarFactory {
+ public static Car getCar(String car) {
+ if (car.equals("五菱")) {
+ return new WuLing();
+ } else if (car.equals("特斯拉")) {
+ return new TesLa();
+ } else {
+ return null;
+ }
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java" "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java"
new file mode 100644
index 0000000..0a9a202
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java"
@@ -0,0 +1,18 @@
+package com.scma.gof23.factory.简单工厂模式;
+
+public class Consumer {
+ public static void main(String[] args) {
+ //工厂模式之前做法
+ /* Car wuLing = new WuLing();
+ Car tes = new TesLa();
+ wuLing.name();
+ tes.name();*/
+
+
+ //工厂模式之后做法
+ Car car = CarFactory.getCar("五菱");
+ car.name();
+ }
+
+
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java" "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java"
new file mode 100644
index 0000000..baa0705
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java"
@@ -0,0 +1,8 @@
+package com.scma.gof23.factory.简单工厂模式;
+
+public class TesLa implements Car {
+ @Override
+ public void name() {
+ System.out.println("特斯拉");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java" "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java"
new file mode 100644
index 0000000..7c27289
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java"
@@ -0,0 +1,8 @@
+package com.scma.gof23.factory.简单工厂模式;
+
+public class WuLing implements Car {
+ @Override
+ public void name() {
+ System.out.println("五菱宏光");
+ }
+}
From d2b0e8bbfb933bc563937e54a9894a4a2f1470c9 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 14 Mar 2021 21:11:56 +0800
Subject: [PATCH 32/36] =?UTF-8?q?=E5=BB=BA=E9=80=A0=E8=80=85=E6=A8=A1?=
=?UTF-8?q?=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../READEME.md" | 15 ++++++
.../demo01/Builder.java" | 10 ++++
.../demo01/Director.java" | 13 +++++
.../demo01/Product.java" | 50 +++++++++++++++++++
.../demo01/Test.java" | 12 +++++
.../demo01/Worker.java" | 38 ++++++++++++++
.../demo02/Builder.java" | 10 ++++
.../demo02/Product.java" | 50 +++++++++++++++++++
.../demo02/Test.java" | 10 ++++
.../demo02/Worker.java" | 40 +++++++++++++++
10 files changed, 248 insertions(+)
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/READEME.md"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Builder.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Director.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Product.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Test.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Worker.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Builder.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Product.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Test.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Worker.java"
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/READEME.md" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/READEME.md"
new file mode 100644
index 0000000..07e4c24
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/READEME.md"
@@ -0,0 +1,15 @@
+### 定义：
+> 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示；
+### 主要作用：
+> 在用户不知道对象的建造过程细节和情况下就可以直接创建复杂的对象
+>
+```java
+解释 用户只需要给出复杂对象的类型和内容，
+建造者模式负责按顺序创建复杂对象（把内部
+建造过程和细节隐藏起来）
+```
+
+
+#### 例子
+工厂 ： 负责制造汽车（组装过程和细节在工厂内）
+汽车购买者： 只需要说出型号 ，然后直接购买即可使用，不必关心车子是怎么组装的
\ No newline at end of file
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Builder.java" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Builder.java"
new file mode 100644
index 0000000..7f0ba78
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Builder.java"
@@ -0,0 +1,10 @@
+package com.scma.gof23.建造者模式.demo01;
+//抽象的建造者： 方法
+public abstract class Builder {
+ abstract void buildA();
+ abstract void buildB();
+ abstract void buildC();
+ abstract void buildD();
+
+ abstract Product getProduct();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Director.java" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Director.java"
new file mode 100644
index 0000000..497e81a
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Director.java"
@@ -0,0 +1,13 @@
+package com.scma.gof23.建造者模式.demo01;
+
+//指挥：核心 负责指挥乳沟构建一个工程
+public class Director {
+ //worker是builder的具体实现。一个builder可能有多个不同的worker
+ public Product build(Builder builder) {
+ builder.buildA();
+ builder.buildB();
+ builder.buildC();
+ builder.buildD();
+ return builder.getProduct();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Product.java" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Product.java"
new file mode 100644
index 0000000..402ac76
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Product.java"
@@ -0,0 +1,50 @@
+package com.scma.gof23.建造者模式.demo01;
+//产品： 房子
+public class Product {
+ private String buildA;
+ private String buildB;
+ private String buildC;
+ private String buildD;
+
+ public String getBuildA() {
+ return buildA;
+ }
+
+ public void setBuildA(String buildA) {
+ this.buildA = buildA;
+ }
+
+ public String getBuildB() {
+ return buildB;
+ }
+
+ public void setBuildB(String buildB) {
+ this.buildB = buildB;
+ }
+
+ public String getBuildC() {
+ return buildC;
+ }
+
+ public void setBuildC(String buildC) {
+ this.buildC = buildC;
+ }
+
+ public String getBuildD() {
+ return buildD;
+ }
+
+ public void setBuildD(String buildD) {
+ this.buildD = buildD;
+ }
+
+ @Override
+ public String toString() {
+ return "Product{" +
+ "buildA='" + buildA + '\'' +
+ ", buildB='" + buildB + '\'' +
+ ", buildC='" + buildC + '\'' +
+ ", buildD='" + buildD + '\'' +
+ '}';
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Test.java" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Test.java"
new file mode 100644
index 0000000..7470508
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Test.java"
@@ -0,0 +1,12 @@
+package com.scma.gof23.建造者模式.demo01;
+
+public class Test {
+ public static void main(String[] args) {
+ //指挥（包工头）
+ Director director = new Director();
+
+ //指挥 具体的工人完成产品
+ Product build = director.build(new Worker());
+ build.toString();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Worker.java" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Worker.java"
new file mode 100644
index 0000000..caf0de7
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo01/Worker.java"
@@ -0,0 +1,38 @@
+package com.scma.gof23.建造者模式.demo01;
+
+public class Worker extends Builder {
+ private Product product;
+
+ public Worker() {
+ product = new Product();
+ }
+
+ @Override
+ void buildA() {
+ product.setBuildA("地基");
+ System.out.println("地基");
+ }
+
+ @Override
+ void buildB() {
+ product.setBuildA("钢筋工程");
+ System.out.println("钢筋工程");
+ }
+
+ @Override
+ void buildC() {
+ product.setBuildA("铺电线");
+ System.out.println("铺电线");
+ }
+
+ @Override
+ void buildD() {
+ product.setBuildA("粉刷墙壁");
+ System.out.println("粉刷墙壁");
+ }
+
+ @Override
+ Product getProduct() {
+ return product;
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Builder.java" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Builder.java"
new file mode 100644
index 0000000..f60f49a
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Builder.java"
@@ -0,0 +1,10 @@
+package com.scma.gof23.建造者模式.demo02;
+
+public abstract class Builder {
+ abstract Builder builderA(String msg);
+ abstract Builder builderB(String msg);
+ abstract Builder builderC(String msg);
+ abstract Builder builderD(String msg);
+
+ abstract Product getProduct();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Product.java" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Product.java"
new file mode 100644
index 0000000..86012d8
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Product.java"
@@ -0,0 +1,50 @@
+package com.scma.gof23.建造者模式.demo02;
+
+public class Product {
+ private String BuilderA ="汉堡";
+ private String BuilderB ="可乐";
+ private String BuilderC ="薯条";
+ private String BuilderD ="甜点";
+
+ public String getBuilderA() {
+ return BuilderA;
+ }
+
+ public void setBuilderA(String builderA) {
+ BuilderA = builderA;
+ }
+
+ public String getBuilderB() {
+ return BuilderB;
+ }
+
+ public void setBuilderB(String builderB) {
+ BuilderB = builderB;
+ }
+
+ public String getBuilderC() {
+ return BuilderC;
+ }
+
+ public void setBuilderC(String builderC) {
+ BuilderC = builderC;
+ }
+
+ public String getBuilderD() {
+ return BuilderD;
+ }
+
+ public void setBuilderD(String builderD) {
+ BuilderD = builderD;
+ }
+
+ @Override
+ public String toString() {
+ return "Product{" +
+ "BuilderA='" + BuilderA + '\'' +
+ ", BuilderB='" + BuilderB + '\'' +
+ ", BuilderC='" + BuilderC + '\'' +
+ ", BuilderD='" + BuilderD + '\'' +
+ '}';
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Test.java" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Test.java"
new file mode 100644
index 0000000..8376cc6
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Test.java"
@@ -0,0 +1,10 @@
+package com.scma.gof23.建造者模式.demo02;
+
+public class Test {
+ public static void main(String[] args) {
+ //服务员
+ Worker worker = new Worker();
+ Product product = worker.getProduct();
+ System.out.println( product.toString());
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Worker.java" "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Worker.java"
new file mode 100644
index 0000000..770db93
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\273\272\351\200\240\350\200\205\346\250\241\345\274\217/demo02/Worker.java"
@@ -0,0 +1,40 @@
+package com.scma.gof23.建造者模式.demo02;
+
+import com.sun.corba.se.spi.orbutil.threadpool.Work;
+
+public class Worker extends Builder {
+ private Product product;
+
+ public Worker() {
+ product = new Product();
+ }
+
+ @Override
+ Builder builderA(String msg) {
+ product.setBuilderA(msg);
+ return this;
+ }
+
+ @Override
+ Builder builderB(String msg) {
+ product.setBuilderB(msg);
+ return this;
+ }
+
+ @Override
+ Builder builderC(String msg) {
+ product.setBuilderC(msg);
+ return this;
+ }
+
+ @Override
+ Builder builderD(String msg) {
+ product.setBuilderD(msg);
+ return this;
+ }
+
+ @Override
+ Product getProduct() {
+ return product;
+ }
+}
From 060665f160a11b5823ba7929a0dd786e09a8284e Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 14 Mar 2021 21:21:00 +0800
Subject: [PATCH 33/36] =?UTF-8?q?=E5=8D=95=E4=BE=8B=E6=A8=A1=E5=BC=8F?=
=?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=90=8D=E7=A7=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../DoubleCheckSingletonle.java" | 2 +-
.../\345\215\225\344\276\213\346\250\241\345\274\217/EHan.java" | 2 +-
.../\345\215\225\344\276\213\346\250\241\345\274\217/LHan.java" | 2 +-
.../Singleton.java" | 2 +-
.../StaticInnerClassSingletonle.java" | 2 +-
.../\345\215\225\345\210\227\346\250\241\345\274\217.md" | 0
6 files changed, 5 insertions(+), 5 deletions(-)
rename gof23/src/main/java/com/scma/gof23/singletonle/DoubleCheckSingletonle.java => "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/DoubleCheckSingletonle.java" (97%)
rename gof23/src/main/java/com/scma/gof23/singletonle/EHan.java => "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/EHan.java" (91%)
rename gof23/src/main/java/com/scma/gof23/singletonle/LHan.java => "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/LHan.java" (92%)
rename gof23/src/main/java/com/scma/gof23/singletonle/Singleton.java => "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/Singleton.java" (65%)
rename gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java => "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/StaticInnerClassSingletonle.java" (94%)
rename "gof23/src/main/java/com/scma/gof23/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md" => "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/\345\215\225\345\210\227\346\250\241\345\274\217.md" (100%)
diff --git a/gof23/src/main/java/com/scma/gof23/singletonle/DoubleCheckSingletonle.java "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/DoubleCheckSingletonle.java"
similarity index 97%
rename from gof23/src/main/java/com/scma/gof23/singletonle/DoubleCheckSingletonle.java
rename to "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/DoubleCheckSingletonle.java"
index 2a3243a..8499b73 100644
--- a/gof23/src/main/java/com/scma/gof23/singletonle/DoubleCheckSingletonle.java
+++ "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/DoubleCheckSingletonle.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.singletonle;
+package com.scma.gof23.单例模式;
/*
diff --git a/gof23/src/main/java/com/scma/gof23/singletonle/EHan.java "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/EHan.java"
similarity index 91%
rename from gof23/src/main/java/com/scma/gof23/singletonle/EHan.java
rename to "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/EHan.java"
index 045cabb..3132b7b 100644
--- a/gof23/src/main/java/com/scma/gof23/singletonle/EHan.java
+++ "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/EHan.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.singletonle;
+package com.scma.gof23.单例模式;
/*
* 从名字上也很好理解，就是“比较勤”，实例在初始化的时候就已经建好了，不
* 管你有没有用到，都先建好了再说。
diff --git a/gof23/src/main/java/com/scma/gof23/singletonle/LHan.java "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/LHan.java"
similarity index 92%
rename from gof23/src/main/java/com/scma/gof23/singletonle/LHan.java
rename to "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/LHan.java"
index b15639e..b99e6f5 100644
--- a/gof23/src/main/java/com/scma/gof23/singletonle/LHan.java
+++ "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/LHan.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.singletonle;
+package com.scma.gof23.单例模式;
/*
* 就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，
* 如果有则返回，没有则新建。有线程安全和线程不安全两种写法，
diff --git a/gof23/src/main/java/com/scma/gof23/singletonle/Singleton.java "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/Singleton.java"
similarity index 65%
rename from gof23/src/main/java/com/scma/gof23/singletonle/Singleton.java
rename to "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/Singleton.java"
index d5e4af1..f479273 100644
--- a/gof23/src/main/java/com/scma/gof23/singletonle/Singleton.java
+++ "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/Singleton.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.singletonle;
+package com.scma.gof23.单例模式;
public enum Singleton {
INSTANCE;
diff --git a/gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/StaticInnerClassSingletonle.java"
similarity index 94%
rename from gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java
rename to "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/StaticInnerClassSingletonle.java"
index 1ab8bfb..1f138e2 100644
--- a/gof23/src/main/java/com/scma/gof23/singletonle/StaticInnerClassSingletonle.java
+++ "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/StaticInnerClassSingletonle.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.singletonle;
+package com.scma.gof23.单例模式;
/*
* 效果类似双检锁，但实现更简单。
* 但这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用
diff --git "a/gof23/src/main/java/com/scma/gof23/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md" "b/gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/\345\215\225\345\210\227\346\250\241\345\274\217.md"
similarity index 100%
rename from "gof23/src/main/java/com/scma/gof23/singletonle/\345\215\225\345\210\227\346\250\241\345\274\217.md"
rename to "gof23/src/main/java/com/scma/gof23/\345\215\225\344\276\213\346\250\241\345\274\217/\345\215\225\345\210\227\346\250\241\345\274\217.md"
From d737fcfd548c4847dd65921b7a2257bf871e9085 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Sun, 14 Mar 2021 21:21:38 +0800
Subject: [PATCH 34/36] =?UTF-8?q?=E5=B7=A5=E5=8E=82=E6=A8=A1=E5=BC=8F?=
=?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=90=8D=E7=A7=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../READEME.md" | 0
.../Car.java" | 5 +++++
.../CarFactory.java" | 2 +-
.../Consumer.java" | 4 +---
.../TesLa.java" | 2 +-
.../TesLaFactory.java" | 2 +-
.../WuLing.java" | 2 +-
.../WuLingFactory.java" | 2 +-
.../Client.java" | 2 +-
.../HuaWeiFactory.java" | 2 +-
.../HuaWeiPhone.java" | 2 +-
.../HuaWeiRouter.java" | 2 +-
.../IPhoneProduct.java" | 2 +-
.../IProductFactory.java" | 2 +-
.../IRouterProduct.java" | 2 +-
.../XiaoMiPhone.java" | 2 +-
.../XiaoMiRouter.java" | 2 +-
.../XiaomiFactory.java" | 2 +-
.../Car.java" | 5 +++++
.../CarFactory.java" | 2 +-
.../Consumer.java" | 2 +-
.../TesLa.java" | 2 +-
.../WuLing.java" | 2 +-
23 files changed, 30 insertions(+), 22 deletions(-)
rename gof23/src/main/java/com/scma/gof23/factory/READEME.md => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/READEME.md" (100%)
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java"
rename "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java" (56%)
rename "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java" (72%)
rename "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java" (69%)
rename "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java" (69%)
rename "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java" (69%)
rename "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java" (69%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java" (87%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java" (82%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java" (89%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java" (89%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java" (72%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java" (77%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java" (72%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java" (89%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java" (89%)
rename "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java" (82%)
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java"
rename "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java" (87%)
rename "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java" (85%)
rename "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java" (69%)
rename "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java" => "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java" (69%)
diff --git a/gof23/src/main/java/com/scma/gof23/factory/READEME.md "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/READEME.md"
similarity index 100%
rename from gof23/src/main/java/com/scma/gof23/factory/READEME.md
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/READEME.md"
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java"
new file mode 100644
index 0000000..d6a9e39
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java"
@@ -0,0 +1,5 @@
+package com.scma.gof23.工厂模式.工厂方法模式;
+
+public interface Car {
+ public void name();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java"
similarity index 56%
rename from "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java"
index bc9fff6..4af3fe3 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/CarFactory.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.工厂方法模式;
+package com.scma.gof23.工厂模式.工厂方法模式;
/*工厂方法模式*/
public interface CarFactory {
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java"
similarity index 72%
rename from "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java"
index 0adac82..6ea2810 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Consumer.java"
@@ -1,6 +1,4 @@
-package com.scma.gof23.factory.工厂方法模式;
-
-import com.scma.gof23.factory.简单工厂模式.CarFactory;
+package com.scma.gof23.工厂模式.工厂方法模式;
/*不改变原来的代码 新增一个车 直接新增一个工厂类 方便扩展*/
public class Consumer {
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java"
similarity index 69%
rename from "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java"
index baa0705..82b9136 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.简单工厂模式;
+package com.scma.gof23.工厂模式.工厂方法模式;
public class TesLa implements Car {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java"
similarity index 69%
rename from "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java"
index 02a9945..458475d 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLaFactory.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.工厂方法模式;
+package com.scma.gof23.工厂模式.工厂方法模式;
public class TesLaFactory implements CarFactory {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java"
similarity index 69%
rename from "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java"
index d8d5cb8..f239888 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLing.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.工厂方法模式;
+package com.scma.gof23.工厂模式.工厂方法模式;
public class WuLing implements Car {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java"
similarity index 69%
rename from "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java"
index a121543..4fd78aa 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/WuLingFactory.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.工厂方法模式;
+package com.scma.gof23.工厂模式.工厂方法模式;
public class WuLingFactory implements CarFactory {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java"
similarity index 87%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java"
index a55de06..903990a 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/Client.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
public class Client {
public static void main(String[] args) {
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java"
similarity index 82%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java"
index 1fc5b7c..acd7eb8 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiFactory.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
public class HuaWeiFactory implements IProductFactory {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java"
similarity index 89%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java"
index 9fa239c..d72ffcb 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiPhone.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
/*华为手机*/
public class HuaWeiPhone implements IPhoneProduct {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java"
similarity index 89%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java"
index 8fff2bc..f38a508 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/HuaWeiRouter.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
/*华为路由器*/
public class HuaWeiRouter implements IRouterProduct {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java"
similarity index 72%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java"
index 8ceeef8..a0a4968 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IPhoneProduct.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
/*手机产品接口
* */
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java"
similarity index 77%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java"
index 893c26a..2a75620 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IProductFactory.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
//抽象产品工厂 （抽象的 抽象）
public interface IProductFactory {
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java"
similarity index 72%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java"
index 1440286..0a99aab 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/IRouterProduct.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
/*路由器产品接口*/
public interface IRouterProduct {
void start();
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java"
similarity index 89%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java"
index 093b58e..8631545 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiPhone.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
/*
* 小米手机*/
public class XiaoMiPhone implements IPhoneProduct {
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java"
similarity index 89%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java"
index c2454d4..f327c54 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaoMiRouter.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
/*小米路由器*/
public class XiaoMiRouter implements IRouterProduct {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java"
similarity index 82%
rename from "gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java"
index d32aeed..d62effa 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217/XiaomiFactory.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.抽象工厂模式;
+package com.scma.gof23.工厂模式.抽象工厂模式;
public class XiaomiFactory implements IProductFactory {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java"
new file mode 100644
index 0000000..0eb0a8b
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java"
@@ -0,0 +1,5 @@
+package com.scma.gof23.工厂模式.简单工厂模式;
+
+public interface Car {
+ public void name();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java"
similarity index 87%
rename from "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java"
index 9d18422..2affd4d 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/CarFactory.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.简单工厂模式;
+package com.scma.gof23.工厂模式.简单工厂模式;
/*简单车工厂 （静态工厂模式） 如果有新车品牌 会改变工厂代码
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java"
similarity index 85%
rename from "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java"
index 0a9a202..6af6fcd 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Consumer.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.简单工厂模式;
+package com.scma.gof23.工厂模式.简单工厂模式;
public class Consumer {
public static void main(String[] args) {
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java"
similarity index 69%
rename from "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java"
index b8a8197..b079187 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/TesLa.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/TesLa.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.工厂方法模式;
+package com.scma.gof23.工厂模式.简单工厂模式;
public class TesLa implements Car {
@Override
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java" "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java"
similarity index 69%
rename from "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java"
rename to "gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java"
index 7c27289..925b2dd 100644
--- "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java"
+++ "b/gof23/src/main/java/com/scma/gof23/\345\267\245\345\216\202\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/WuLing.java"
@@ -1,4 +1,4 @@
-package com.scma.gof23.factory.简单工厂模式;
+package com.scma.gof23.工厂模式.简单工厂模式;
public class WuLing implements Car {
@Override
From bd5e4cde10d9afd7a9d62c291a0c1d63bf4f6765 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Mon, 15 Mar 2021 23:56:06 +0800
Subject: [PATCH 35/36] =?UTF-8?q?=E8=AE=BE=E8=AE=A1=E6=A8=A1=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../Car.java" | 5 --
.../Car.java" | 5 --
.../READEMA.md" | 14 +++++
.../Client.java" | 12 ++++
.../Host.java" | 8 +++
.../Proxy.java" | 24 ++++++++
.../Rent.java" | 5 ++
.../READEMA.md" | 3 +
.../demo01/TestClone.java" | 18 ++++++
.../demo01/Video.java" | 53 +++++++++++++++++
.../demo02/TestClone.java" | 21 +++++++
.../demo02/Video.java" | 58 +++++++++++++++++++
.../Apple.java" | 9 +++
.../Brand.java" | 5 ++
.../Computer.java" | 43 ++++++++++++++
.../Lenovo.java" | 9 +++
.../READEME.md" | 2 +
.../Test.java" | 19 ++++++
.../Adapee.java" | 8 +++
.../Adapter.java" | 9 +++
.../Adapter2.java" | 17 ++++++
.../Computer.java" | 23 ++++++++
.../NetToUSB.java" | 7 +++
23 files changed, 367 insertions(+), 10 deletions(-)
delete mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java"
delete mode 100644 "gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/READEMA.md"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Client.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Host.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Proxy.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Rent.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/READEMA.md"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo01/TestClone.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo01/Video.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo02/TestClone.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo02/Video.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Apple.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Brand.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Computer.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Lenovo.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/READEME.md"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Test.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapee.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapter.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapter2.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Computer.java"
create mode 100644 "gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/NetToUSB.java"
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java" "b/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java"
deleted file mode 100644
index c2df137..0000000
--- "a/gof23/src/main/java/com/scma/gof23/factory/\345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217/Car.java"
+++ /dev/null
@@ -1,5 +0,0 @@
-package com.scma.gof23.factory.工厂方法模式;
-
-public interface Car {
- public void name();
-}
diff --git "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java" "b/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java"
deleted file mode 100644
index 051f317..0000000
--- "a/gof23/src/main/java/com/scma/gof23/factory/\347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217/Car.java"
+++ /dev/null
@@ -1,5 +0,0 @@
-package com.scma.gof23.factory.简单工厂模式;
-
-public interface Car {
- public void name();
-}
diff --git "a/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/READEMA.md" "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/READEMA.md"
new file mode 100644
index 0000000..3241c3e
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/READEMA.md"
@@ -0,0 +1,14 @@
+代理模式
+
+1、静态代理
+
+2、动态代理
+https://www.bilibili.com/video/BV1mc411h719?p=11&spm_id_from=pageDriver
+
+静态代理优点 ：
+1、使真是角色的操作更加纯粹，不用关注一些公共的业务
+2、将业务交给代理角色，实现了业务的分工
+3、公共业务发生扩展时，方便集中管理
+
+静态代理缺点：
+1、一个真实角色就会产生一个代理 代码翻倍
\ No newline at end of file
diff --git "a/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Client.java" "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Client.java"
new file mode 100644
index 0000000..07abb03
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Client.java"
@@ -0,0 +1,12 @@
+package com.scma.gof23.代理模式.静态代理;
+//客户
+public class Client {
+ public static void main(String[] args) {
+ //房东要出租房子
+ Host host = new Host();
+ // 代理 中介 还有一些附属操作
+ Proxy proxy = new Proxy(host);
+ // 客户通过中介 直接租房
+ proxy.rent();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Host.java" "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Host.java"
new file mode 100644
index 0000000..2750bb5
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Host.java"
@@ -0,0 +1,8 @@
+package com.scma.gof23.代理模式.静态代理;
+//房东
+public class Host implements Rent{
+ @Override
+ public void rent() {
+ System.out.println("房东要出租房子");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Proxy.java" "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Proxy.java"
new file mode 100644
index 0000000..447bf10
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Proxy.java"
@@ -0,0 +1,24 @@
+package com.scma.gof23.代理模式.静态代理;
+//代理
+public class Proxy implements Rent {
+ private Host host;
+ public Proxy(Host host){
+ this.host=host;
+ }
+ @Override
+ public void rent() {
+ seeHouse();
+ host.rent();
+ hetong();
+ }
+
+ //看房
+ public void seeHouse(){
+ System.out.println("看房");
+ }
+ //签合同
+ public void hetong(){
+ System.out.println("签合同");
+ }
+
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Rent.java" "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Rent.java"
new file mode 100644
index 0000000..029aaf0
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\344\273\243\347\220\206\346\250\241\345\274\217/\351\235\231\346\200\201\344\273\243\347\220\206/Rent.java"
@@ -0,0 +1,5 @@
+package com.scma.gof23.代理模式.静态代理;
+
+public interface Rent {
+ void rent();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/READEMA.md" "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/READEMA.md"
new file mode 100644
index 0000000..ea5d528
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/READEMA.md"
@@ -0,0 +1,3 @@
+实现克隆
+1、实现一个接口
+2、重写一个方法
\ No newline at end of file
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo01/TestClone.java" "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo01/TestClone.java"
new file mode 100644
index 0000000..effd1e1
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo01/TestClone.java"
@@ -0,0 +1,18 @@
+package com.scma.gof23.原型模式.demo01;
+
+import java.util.Date;
+
+public class TestClone {
+ public static void main(String[] args) throws CloneNotSupportedException {
+ //原型对象
+ Date date = new Date(); //该对象 都共用了 这个是浅克隆
+ Video video = new Video("Java设计模式", date);
+
+ System.out.println(video.toString()+"--->"+video.hashCode());
+
+ //克隆 但只克隆了引用 属于浅克隆
+ Video clone = (Video)video.clone();
+ System.out.println(clone.toString()+"--->"+clone.hashCode());
+
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo01/Video.java" "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo01/Video.java"
new file mode 100644
index 0000000..be52482
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo01/Video.java"
@@ -0,0 +1,53 @@
+package com.scma.gof23.原型模式.demo01;
+
+import java.util.Date;
+
+/*
+
+实现克隆
+1、实现一个接口
+2、重写一个方法
+
+* */
+//视频类
+public class Video implements Cloneable {
+ private String name;
+ private Date createTime;
+
+ @Override
+ protected Object clone() throws CloneNotSupportedException {
+ return super.clone();
+ }
+
+ public Video() {
+ }
+
+ public Video(String name, Date createTime) {
+ this.name = name;
+ this.createTime = createTime;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public Date getCreateTime() {
+ return createTime;
+ }
+
+ public void setCreateTime(Date createTime) {
+ this.createTime = createTime;
+ }
+
+ @Override
+ public String toString() {
+ return "Video{" +
+ "name='" + name + '\'' +
+ ", createTime=" + createTime +
+ '}';
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo02/TestClone.java" "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo02/TestClone.java"
new file mode 100644
index 0000000..352ba73
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo02/TestClone.java"
@@ -0,0 +1,21 @@
+package com.scma.gof23.原型模式.demo02;
+
+import java.util.Date;
+
+public class TestClone {
+ public static void main(String[] args) throws CloneNotSupportedException {
+ //原型对象
+ Date date = new Date(); //该对象 都共用了 这个是浅克隆
+ Video video = new Video("Java设计模式", date);
+
+ System.out.println(video.toString()+"--->"+video.hashCode());
+
+ //克隆 但只克隆了引用 属于浅克隆
+ Video clone = (Video)video.clone();
+ System.out.println(clone.toString()+"--->"+clone.hashCode());
+
+
+ //深克隆 有多种实现 有序列化 反序列化 修改clone方法
+
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo02/Video.java" "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo02/Video.java"
new file mode 100644
index 0000000..d3f9de4
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\345\216\237\345\236\213\346\250\241\345\274\217/demo02/Video.java"
@@ -0,0 +1,58 @@
+package com.scma.gof23.原型模式.demo02;
+
+import java.util.Date;
+
+/*
+
+实现克隆
+1、实现一个接口
+2、重写一个方法
+
+* */
+//视频类
+public class Video implements Cloneable {
+ private String name;
+ private Date createTime;
+
+ @Override
+ protected Object clone() throws CloneNotSupportedException {
+// return super.clone();//只能浅克隆
+ //实现深克隆
+ Object obj = super.clone();
+ Video v = (Video) obj;
+ v.createTime = (Date) this.createTime.clone(); //将对象的属性也进行克隆
+ return v;
+ }
+
+ public Video() {
+ }
+
+ public Video(String name, Date createTime) {
+ this.name = name;
+ this.createTime = createTime;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public Date getCreateTime() {
+ return createTime;
+ }
+
+ public void setCreateTime(Date createTime) {
+ this.createTime = createTime;
+ }
+
+ @Override
+ public String toString() {
+ return "Video{" +
+ "name='" + name + '\'' +
+ ", createTime=" + createTime +
+ '}';
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Apple.java" "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Apple.java"
new file mode 100644
index 0000000..27bae92
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Apple.java"
@@ -0,0 +1,9 @@
+package com.scma.gof23.桥接模式;
+
+//苹果品牌
+public class Apple implements Brand {
+ @Override
+ public void info() {
+ System.out.print("苹果品牌->");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Brand.java" "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Brand.java"
new file mode 100644
index 0000000..e9c9c83
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Brand.java"
@@ -0,0 +1,5 @@
+package com.scma.gof23.桥接模式;
+//品牌
+public interface Brand {
+ void info();
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Computer.java" "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Computer.java"
new file mode 100644
index 0000000..f2a1991
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Computer.java"
@@ -0,0 +1,43 @@
+package com.scma.gof23.桥接模式;
+
+//抽象的电脑类类型
+public class Computer {
+ //多使用组合
+ protected Brand brand;
+
+ public Computer(Brand brand){
+ this.brand=brand;
+ }
+
+ public void info(){
+ brand.info(); //自带的品牌
+ }
+}
+
+
+//具体的电脑类型
+class Desktop extends Computer{
+
+ public Desktop(Brand brand) {
+ super(brand);
+ }
+ @Override
+ public void info(){
+ super.info();
+ System.out.println("台式机");
+ }
+}
+
+class Laptop extends Computer{
+ public Laptop(Brand brand) {
+ super(brand);
+
+ }
+
+ @Override
+ public void info(){
+ super.info();
+ System.out.println("笔记本电脑");
+ }
+}
+
diff --git "a/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Lenovo.java" "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Lenovo.java"
new file mode 100644
index 0000000..f55ee02
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Lenovo.java"
@@ -0,0 +1,9 @@
+package com.scma.gof23.桥接模式;
+
+//联想品牌
+public class Lenovo implements Brand {
+ @Override
+ public void info() {
+ System.out.print("联想品牌->");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/READEME.md" "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/READEME.md"
new file mode 100644
index 0000000..42f5d4c
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/READEME.md"
@@ -0,0 +1,2 @@
+概念
+1、桥接模式是将抽象部分与它的实现部分分离，使它们可以独立地变化，它是一种对象结构模型，又称为柄体模式或者接口模式
diff --git "a/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Test.java" "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Test.java"
new file mode 100644
index 0000000..5ac5e5b
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\346\241\245\346\216\245\346\250\241\345\274\217/Test.java"
@@ -0,0 +1,19 @@
+package com.scma.gof23.桥接模式;
+
+//多个维度属性的桥接
+
+//苹果 笔记本
+//联想 台式机
+//一共四种组合啊 666
+public class Test{
+
+
+ public static void main(String[] args) {
+ //苹果笔记本
+ Laptop laptop = new Laptop(new Apple());
+ laptop.info();
+ //联想台式机
+ Desktop desktop = new Desktop(new Apple());
+ desktop.info();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapee.java" "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapee.java"
new file mode 100644
index 0000000..2c6b586
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapee.java"
@@ -0,0 +1,8 @@
+package com.scma.gof23.适配器模式;
+
+//要被适配的类 ： 网线
+public class Adapee {
+ public void request(){
+ System.out.println("连接上网");
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapter.java" "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapter.java"
new file mode 100644
index 0000000..3a923f4
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapter.java"
@@ -0,0 +1,9 @@
+package com.scma.gof23.适配器模式;
+//真正的适配器 连接网线 连接电脑
+ public class Adapter extends Adapee implements NetToUSB{
+
+ @Override
+ public void handlerRequest() {
+ super.request();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapter2.java" "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapter2.java"
new file mode 100644
index 0000000..425dce6
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Adapter2.java"
@@ -0,0 +1,17 @@
+package com.scma.gof23.适配器模式;
+
+//1、继承 （类适配器，单继承）
+//2、组合（对象适配器，常用）
+//真正的适配器2 连接网线 连接电脑
+public class Adapter2 implements NetToUSB {
+ private Adapee adapee;
+
+ public Adapter2(Adapee adapee) {
+ this.adapee = adapee;
+ }
+
+ @Override
+ public void handlerRequest() {
+ adapee.request();
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Computer.java" "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Computer.java"
new file mode 100644
index 0000000..8455aea
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/Computer.java"
@@ -0,0 +1,23 @@
+package com.scma.gof23.适配器模式;
+
+//客户端 想上网，但是插不上网线
+public class Computer {
+ //电脑要上网 需要连接上转接器 才可以上网
+ public void net(NetToUSB adapter) {
+ //上网的具体实现 ，找一个转接头
+ adapter.handlerRequest();
+ }
+
+ public static void main(String[] args) {
+ //电脑 适配器 网线
+ Computer computer = new Computer();//电脑
+ Adapter adapter = new Adapter();//类适配器
+ computer.net(adapter);
+
+ //组合创建的适配器
+ Adapee adapee = new Adapee();//网线
+ Adapter2 adapter2 = new Adapter2(adapee); //组合适配器
+ computer.net(adapter2);
+
+ }
+}
diff --git "a/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/NetToUSB.java" "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/NetToUSB.java"
new file mode 100644
index 0000000..f7f7360
--- /dev/null
+++ "b/gof23/src/main/java/com/scma/gof23/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217/NetToUSB.java"
@@ -0,0 +1,7 @@
+package com.scma.gof23.适配器模式;
+//接口转换器的抽象
+public interface NetToUSB {
+ //作用： 处理请求，网线 =》 usb
+ public void handlerRequest();
+
+}
From 65c7cfde3c454c1317848eb471504ed07631c2e5 Mon Sep 17 00:00:00 2001
From: scma <59968873@qq.com>
Date: Tue, 16 Mar 2021 23:56:51 +0800
Subject: [PATCH 36/36] =?UTF-8?q?=E6=95=B0=E7=BB=84=E4=B8=AD=E7=9A=84?=
=?UTF-8?q?=E7=AC=ACK=E4=B8=AA=E6=9C=80=E5=B0=8F=E5=85=83=E7=B4=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...45\260\217\345\205\203\347\264\24092.java" | 93 +++++++++++++++++++
1 file changed, 93 insertions(+)
create mode 100644 "\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\260\217\345\205\203\347\264\24092.java"
diff --git "a/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\260\217\345\205\203\347\264\24092.java" "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\260\217\345\205\203\347\264\24092.java"
new file mode 100644
index 0000000..1b4efcf
--- /dev/null
+++ "b/\347\256\227\346\263\225\346\225\260\346\215\256\347\273\223\346\236\204/src/main/java/leetcode_normal/\346\225\260\347\273\204/\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\260\217\345\205\203\347\264\24092.java"
@@ -0,0 +1,93 @@
+package leetcode_normal.数组;
+
+/*
+ * 在未排序的数组中找到第 k 个最大的元素。请注意，
+ * 你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素
+ * */
+public class 数组中的第K个最小元素92 {
+ public static void main(String[] args) {
+ int[] arr = {3, 2, 7, 1, 2, 4, 5, 5, 6};
+// findK(arr,2);
+ System.out.println(findK1(arr, 5));
+
+ }
+
+ public static int findK1(int[] arr, int k) {
+ if (k > arr.length) {
+ return 0;
+ }
+ int[] arry = new int[k];
+ System.arraycopy(arr, 0, arry, 0, k);
+
+ for (int i = k / 2 - 1; i >= 0; i--) {
+ BigHeap(arry, i, k); //前K个数 构建大根堆
+ }
+
+// 后面的所有的数 维护大根堆
+
+ for (int i = k; i < arr.length; i++) {
+ if (arr[i] < arry[0]) {
+ arry[0] = arr[i];
+ BigHeap(arry, 0, k);
+ }
+ }
+ return arry[0];
+ }
+
+ public static void BigHeap(int[] arr, int index, int len) {
+ int temp = arr[index];
+ for (int k = 2 * index + 1; k < len; k = 2 * k + 1) {
+ if (k + 1 < len && arr[k + 1] > arr[k]) {
+ k++;
+ }
+ if (temp < arr[k]) {
+ arr[index] = arr[k];
+ index = k;
+ } else {
+ break;
+ }
+ }
+ arr[index] = temp;
+
+ }
+
+
+ // public int findKthLargest(int[] nums, int k) {
+// QuikSort(nums, 0, nums.length - 1);
+// return nums[nums.length-k];
+// }
+ public static int findK(int[] arr, int k) {
+ QuikSort(arr, 0, arr.length - 1);
+ return arr[arr.length - k];
+ }
+
+
+ public static void QuikSort(int[] arr, int low, int high) {
+ if (arr.length == 0) {
+ return;
+ }
+ int l = low;
+ int r = high;
+ if (r < l) {
+ return;
+ }
+ int tar = arr[l];
+ while (r > l) {
+ while (r > l && arr[r] >= tar) {
+ r--;
+ }
+ arr[l] = arr[r];
+ while (r > l && arr[l] < tar) {
+ l++;
+ }
+ arr[r] = arr[l];
+ }
+ arr[l] = tar;
+ QuikSort(arr, low, l - 1);
+ QuikSort(arr, l + 1, high);
+ }
+
+
+ /*使用堆排序 维护大根堆*/
+
+}