java复制代码@Configuration
@EnableWebSecurity
@Slf4j
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

	@Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        // 数据没有持久化，只是保存在内存中
        auth.inMemoryAuthentication()
                .withUser("javalover").password(passwordEncoder().encode("123456")).roles("USER")
                .and()
                .withUser("admin").password(passwordEncoder().encode("123456")).roles("ADMIN");
    }
    // 授权相关操作
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        log.info("=== SecurityConfiguration.authorize ===");
        http
            // 登出 所有用户都可以访问
            .logout().permitAll()
                .deleteCookies("JSESSIONID")
            .and()
                .rememberMe()
            // ...省略其他配置
            ;
    }


}

html复制代码<form action="/login" method="post">
    <table>
        <tr>
            <input name="username" placeholder="用户名">
        </tr>
        <tr>
            <input name="password" placeholder="密码">
        </tr>
        <tr>
            <td>记住我:</td>
            <td><input type="checkbox" name="remember-me" /></td>
        </tr>
    </table>
        <button type="submit">登录</button>
    </form>

java复制代码.logout().permitAll()
    .deleteCookies("JSESSIONID")
    .and()
    .rememberMe()
    .tokenValiditySeconds(86400)
    .and()

java复制代码.rememberMe()
    .key("privateKey")
    .tokenValiditySeconds(86400)

python复制代码data = [1, 2, 3, 4, -5]
  
# 使用列表推导式
result = [i for i in data if i >= 0]
  
# 使用 fliter 过滤函数
result = filter(lambda x: x >= 0, data)

python复制代码from random import randint
  
d = {x: randint(50, 100) for x in range(1, 21)}
r = {k: v for k, v in d.items() if v > 80}

python复制代码from random import randint, sample
  
s1 = {x: randint(1, 4) for x in sample("abfcdrg", randint(1, 5))}
d = {k: v for k, v in zip(s1.values(), s1.keys())}

python复制代码# 可以使用字典来统计，以列表中的数据为键，以出现的次数为值
from random import randint
  
# 构造随机序列
data = [randint(0, 20) for _ in range(30)]
  
# 列表中出现数字出现的次数
d = dict.fromkeys(data, 0)
  
for v in d:
  d[v] += 1

python复制代码# 直接使用 collections 模块下面的 Counter 对象
from collections import Counter
from random import randint
  
data = [randint(0, 20) for _ in range(30)]
  
c2 = Counter(data)
  
# 查询元素出现次数
c2[14]
  
# 统计频度出现最高的3个数
c2.most_common(3)

python复制代码import re
from collections import Counter
  
# 统计某个文章中英文单词的词频
with open("test.txt", "r", encoding="utf-8") as f:
  d = f.read()
  
# 所有的单词列表
total = re.split("\W+", d)
result = Counter(total)
print(result.most_common(10))

python复制代码# 利用 zip 将字典转化为元组，再用 sorted 进行排序
from random import randint
  
data = {x: randint(60, 100) for x in "xyzfafs"}
sorted(data)
data = sorted(zip(data.values(), data.keys()))

python复制代码# 利用 sorted 函数的 key 参数
from random import randint
  
data = {x: randint(60, 100) for x in "xyzfafs"}
data.items()
sorted(data.items(), key=lambda x: x[1])

python复制代码from random import randint, sample
from functools import reduce
  
# 模拟随机的进球球员和进球数
s1 = {x: randint(1, 4) for x in sample("abfcdrg", randint(1, 5))}
s2 = {x: randint(1, 4) for x in sample("abfcdrg", randint(1, 5))}
s3 = {x: randint(1, 4) for x in sample("abfcdrg", randint(1, 5))}
  
# 首先获取字典的 keys，然后取每轮比赛 key 的交集。由于比赛轮次数是不定的，所以使用 map 来批量操作
# map(dict.keys, [s1, s2, s3])
  
# 然后一直累积取其交集，使用 reduce 函数
reduce(lambda x, y: x & y, map(dict.keys, [s1, s2, s3]))

scss复制代码DDL(Data Definition Language): 数据定义语言。用来操作数据库，表，列等。
DML(Data Manipulation Language): 数据操作语言。用来对数据库中表的数据进行增删改。
DQL(Data Query Language): 数据查询语言。用来查询数据库中表的记录（数据)。
DCL(Data Control Language): 数据控制语言。用来定义数据库的访问权限和安全级别，及创建用户。

sql复制代码查询所有数据库
SHOW DATABASES;

查询数据库的创建语句
SHOW CREATE DATABASE 数据库名称；

创建数据库
CREATE DATABASE 数据库名称;

创建数据库（判断，如果不存在则创建）
CREATE DATABASE IF NOT EXISTS 数据库名称；

创建数据库（指定字符集）
CREATE DATABASE 数据库名称 CHARACTER SET 字符集名称；

ini复制代码SHOW DATABASES;

sql复制代码SHOW CREATE DATABASE mysql;
// 执行效果
CREATE DATABASE `mysql` /*!40100 DEFAULT CHARACTER SET utf8 */

sql复制代码CREATE DATABASE IF NOT EXISTS db2;

sql复制代码CREATE DATABASE db3 CHARACTER SET utf8;

SHOW CREATE DATABASE db3;
CREATE DATABASE `db3` /*!40100 DEFAULT CHARACTER SET utf8 */

sql复制代码-- 练习：创建db4数据库、如果不存在则创建，指定字符集为gbk
Create database if not exists db4 character set gbk;
-- 查看db4数据库的字符集
SHOW CREATE DATABASE db4;

sql复制代码修改数据库（修改字符集）
ALTER DATABASE 数据库名称 CHARACTER SET 字符集名称;
删除数据库
DROP DATABASE 数据库名称;
删除数据库（判断，如果存在则删除）
DROP DATABASE IF EXISTS 数据库名称；
使用数据库
USE 数据库名称;
查看当前使用的数据库
SELECT DATABASE();

sql复制代码ALTER DATABASE db4 CHARACTER SET utf8;
SHOW CREATE DATABASE db4;
DROP DATABASE db2;
DROP DATABASE IF EXISTS db2;
USE db4;
SELECT DATABASE();

sql复制代码查询所有的数据表
show tables;

查询表结构
desc 表名;

查询表字符集
show table status from 库名 like '表名';

sql复制代码USE mysql;
show tables;
desc user;
show table status from mysql like 'user';

lua复制代码创建数据表

create table 表名(
    列名 数据类型 约束,
    列名 数据类型 约束,
    .......
    列名 数据类型 约束,
);

sql复制代码-- 创建一个product 商品表 （商品编号、商品名称、商品价格、商品库存、上架时间）
use db3;
create table product(
	id int,
    NAME varchar(20),
    price double,
    stock int,
    insert_time DATE
);

-- 查看product表详细结构
desc product;

sql复制代码修改表名
alter table 表名 rename to 新表名;
修改表的字符集
alter table 表名 character set 字符集名称;
单独添加一列
alter table 表名 add 列名 数据类型;
修改某列的数据类型
alter table 表名 modify 列名 新数据类型;
修改列名和数据类型
alter table 表名 change 列名 新列名 新数据类型;
删除某一列
alter table 表名 drop 列名;

sql复制代码-- 修改product表名为product2
alter table product rename to product2;
-- 查看db3 数据库中product2数据表字符集
show table status from db3 like 'product2';
-- 修改product2数据表字符集为gbk
alter table product2 character set gbk;
-- 查看db3 数据库中product2数据表字符集
show table status from db3 like 'product2';

-- 给product2表添加一列color
alter table product2 add color varchar(10);

-- 将color数据类型修改为int
alter table product2 modify color int;
 
desc product2;

-- 将color修改为address
alter table product2 change color address varchar(200);

-- 删除address列
alter table product2 drop address;

sql复制代码删除数据表
DROP table 表名;

删除数据表（判断，如果存在则删除）
drop table if exists 表名;

sql复制代码-- 删除product2 表
DROP table product2;
-- 删除Product2表，如果存在则删除
DROP table if exists product2;

java复制代码public void test1(){
//1 数据库操作
//2 发送MQ消息
}

java复制代码public void test1(){
//1 发送MQ消息
//2 数据库操作
}

java复制代码@Transactional
public void test1(){
//1 发送MQ消息
//2 数据库操作
}

java复制代码@Transactional
public void test1(){
//1 数据库操作
//2 发送MQ消息
}

python复制代码d = collections.defaultdict(list)		# 一个空字典

d['key']	# []
d.get('key')	# None

csharp复制代码public interface Executor {
    void execute(Runnable command);
}

typescript复制代码class DirectExecutor implements Executor {
  public void execute(Runnable r) {
    r.run();
  }
}}

typescript复制代码class ThreadPerTaskExecutor implements Executor {
  public void execute(Runnable r) {
    new Thread(r).start();
  }
}}

java复制代码 class SerialExecutor implements Executor {
   final Queue<Runnable> tasks = new ArrayDeque<>();
   final Executor executor;
   Runnable active;
   
   SerialExecutor(Executor executor) {
     this.executor = executor;
   }
   
   public synchronized void execute(Runnable r) {
     tasks.add(() -> {
       try {
         r.run();
       } finally {
         scheduleNext();
       }
     });
     if (active == null) {
       scheduleNext();
     }
   }
​
   protected synchronized void scheduleNext() {
     if ((active = tasks.poll()) != null) {
       executor.execute(active);
     }
  }
}}

csharp复制代码void shutdown();
​
List<Runnable> shutdownNow();
​
boolean isShutdown();
​
boolean isTerminated();
​
boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

scss复制代码void shutdownAndAwaitTermination(ExecutorService pool) {
  pool.shutdown(); // Disable new tasks from being submitted
  try {
    // Wait a while for existing tasks to terminate
    if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
      pool.shutdownNow(); // Cancel currently executing tasks
      // Wait a while for tasks to respond to being cancelled
      if (!pool.awaitTermination(60, TimeUnit.SECONDS))
          System.err.println("Pool did not terminate");
    }
  } catch (InterruptedException ie) {
    // (Re-)Cancel if current thread also interrupted
    pool.shutdownNow();
    // Preserve interrupt status
    Thread.currentThread().interrupt();
  }
}}

swift复制代码<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
​
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

java复制代码public static ExecutorService newCachedThreadPool() {
  return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                60L, TimeUnit.SECONDS,
                                new SynchronousQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
  return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                60L, TimeUnit.SECONDS,
                                new SynchronousQueue<Runnable>(),
                                threadFactory);
}
public static ExecutorService newSingleThreadExecutor() {
  return new FinalizableDelegatedExecutorService
    (new ThreadPoolExecutor(1, 1,
                            0L, TimeUnit.MILLISECONDS,
                            new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
  return new FinalizableDelegatedExecutorService
    (new ThreadPoolExecutor(1, 1,
                            0L, TimeUnit.MILLISECONDS,
                            new LinkedBlockingQueue<Runnable>(),
                            threadFactory));
}
public static ExecutorService newFixedThreadPool(int nThreads) {
  return new ThreadPoolExecutor(nThreads, nThreads,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
  return new ThreadPoolExecutor(nThreads, nThreads,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory);
}

java复制代码public interface Future<V> {
​
  // 尝试取消任务
  // 1. 任务已经完成、任务已经取消、任务由于其他原因不能被取消 都将返回失败
  // 2. 在调用cancle时，该任务尚未启动，则不运行任务
  // 3. 如果任务已经启动，则mayInterruptIfRunning参数确定是否应该中断执行该任务的线程来取消任务
  // 4. 该方法返回后，不管是否返回成功，后续调用isDone方法都返回true
  // 5. 该方法返回成功后，后续调用isCancleed方法都返回true
  boolean cancel(boolean mayInterruptIfRunning);
  
  // 判断计算是否在执行完之前被取消了
  boolean isCancelled();  
  
  // 判断计算是否已经执行完成
  boolean isDone();
  
  // 阻塞检索计算结果
  V get() throws InterruptedException, ExecutionException;
  
  // 阻塞检索计算结果或者超时后返回
  V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException;
}

scss复制代码public <T> Future<T> submit(Callable<T> task) {
  if (task == null) throw new NullPointerException();
  RunnableFuture<T> ftask = newTaskFor(task);
  execute(ftask);
  return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
  return new FutureTask<T>(callable);
}

shell复制代码docker create [OPTIONS] IMAGE [COMMAND] [ARG...]

# 使用docker镜像nginx:latest创建一个容器,并将容器命名为mynginx
# docker create  --name mynginx  nginx:latest

shell复制代码docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

# 使用docker镜像nginx:latest以后台模式启动一个容器,并将容器命名为mynginx
# docker run --name mynginx -d nginx:latest

shell复制代码docker rename [CONTAINER_NAME] [NEW_CONTAINER_NAME]

shell复制代码docker run [IMAGE] [COMMAND]

shell复制代码docker run --rm [IMAGE]

shell复制代码docker run -td [IMAGE]

shell复制代码docker run -it [IMAGE]

shell复制代码docker run -it-rm [IMAGE]

shell复制代码docker exec -it [container]

shell复制代码docker rm [CONTAINER]

shell复制代码docker update [CONTAINER]

shell复制代码docker start [CONTAINER]

shell复制代码docker stop [CONTAINER]

shell复制代码docker restart [CONTAINER]

shell复制代码docker pause [CONTAINER]

shell复制代码docker unpause [CONTAINER]

shell复制代码docker wait [CONTAINER]

shell复制代码docker kill [CONTAINER]

shell复制代码docker attach [CONTAINER]

shell复制代码docker build [URL/FILE]

shell复制代码docker build -t <tag> [URL/FILE]

shell复制代码docker pull [IMAGE]

shell复制代码docker push [IMAGE]

shell复制代码docker import [URL/FILE]

shell复制代码docker commit [CONTAINER] [NEW_IMAGE_NAME]

shell复制代码docker rmi [IMAGE]

shell复制代码docker load [TAR_FILE/STDIN_FILE]

shell复制代码docker save [IMAGE] > [TAR_FILE]

shell复制代码docker ps

shell复制代码docker ps -a

shell复制代码docker logs [CONTAINER]

shell复制代码docker inspect [OBJECT_NAME/ID]

shell复制代码docker events [CONTAINER]

shell复制代码docker port [CONTAINER]

shell复制代码docker top [CONTAINER]

shell复制代码docker stats [CONTAINER]

shell复制代码docker diff [CONTAINER]

shell复制代码docker [image] ls

shell复制代码docker history [IMAGE]

shell复制代码docker network ls

shell复制代码docker network rm [NETWORK]

shell复制代码docker network inspect [NETWORK]

shell复制代码docker network connect [NETWORK] [CONTAINER]

shell复制代码docker network disconnect [NETWORK] [CONTAINER]

shell复制代码# docker cp 容器名：要拷贝的文件在容器里面的路径   要拷贝到宿主机的相应路径 
docker cp testtomcat:/usr/local/tomcat/webapps/test/js/test.js /root

shell复制代码# docker cp 要拷贝的文件路径 容器名:要拷贝到容器里面对应的路径
docker cp /root/test.js testtomcat:/usr/local/tomcat/webapps/test/js

java复制代码    public void reverseString(char[] s) {
        int head = 0;
        int end = s.length - 1;
        char tmp;
        while (head < end){
            tmp = s[end];
            s[end] = s[head];
            s[head] = tmp;
            head++;
            end--;
        }
    }

java复制代码class Solution {
    public String reverseStr(String s, int k) {
        char[] arr = s.toCharArray();
        int len = s.length();
        int head = 0;
        int last = 2 * k - 1;
        while (last <= len - 1){
            reverse(head, head + k - 1, arr);
            last += 2 * k;
            head += 2 * k;
        }
        int end = (len - 1 - head < k) ? len - 1 : head + k - 1;
        reverse(head, end, arr);
        return String.valueOf(arr);
    }

    public void reverse(int first, int end, char[] arr){
        while (first < end){
            char tmp = arr[first];
            arr[first] = arr[end];
            arr[end] = tmp;
            first++;
            end--;
        }
    }
}

java复制代码class Solution {
    public String replaceSpace(String s) {
    	//用StringBuffer单线程更快
        StringBuffer stb = new StringBuffer();
        for (int i = 0; i < s.length(); i++) {
            char point = s.charAt(i); 
            if (point == ' '){
                stb.append("%20");
            }else {
                stb.append(point);
            }
        }
        return stb.toString();
    }
}

java复制代码public String replaceSpace(String s) {
    if(s == null || s.length() == 0){
        return s;
    }
    //扩充空间，空格数量2倍
    StringBuilder str = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
        if(s.charAt(i) == ' '){
            str.append("  ");
        }
    }
    //若是没有空格直接返回
    if(str.length() == 0){
        return s;
    }
    //有空格情况 定义两个指针
    int left = s.length() - 1;//左指针：指向原始字符串最后一个位置
    s += str.toString();
    int right = s.length()-1;//右指针：指向扩展字符串的最后一个位置
    char[] chars = s.toCharArray();
    while(left>=0){
        if(chars[left] == ' '){
            chars[right--] = '0';
            chars[right--] = '2';
            chars[right] = '%';
        }else{
            chars[right] = chars[left];
        }
        left--;
        right--;
    }
    return new String(chars);
}

java复制代码	//法一
    public static String reverseWords(String s) {
        String[] s1 = s.split(" ");
        StringBuffer stb = new StringBuffer();
        for (int i = s1.length - 1; i >= 0; i--){
            if (!s1[i].equals("")) {
                stb.append(s1[i] + " ");
            }
        }
        //移除最后一个空格
        return stb.toString().substring(0,stb.length() - 1);
    }

    public static void main(String[] args) {
        System.out.println(reverseWords("We      are happy"));//happy are We
    }

java复制代码//法二
class Solution {
   /**
     * 不使用Java内置方法实现
     * <p>
     * 1.去除首尾以及中间多余空格
     * 2.反转整个字符串
     * 3.反转各个单词
     */
    public String reverseWords(String s) {
        // System.out.println("ReverseWords.reverseWords2() called with: s = [" + s + "]");
        // 1.去除首尾以及中间多余空格
        StringBuilder sb = removeSpace(s);
        // 2.反转整个字符串
        reverseString(sb, 0, sb.length() - 1);
        // 3.反转各个单词
        reverseEachWord(sb);
        return sb.toString();
    }

    private StringBuilder removeSpace(String s) {
        // System.out.println("ReverseWords.removeSpace() called with: s = [" + s + "]");
        int start = 0;
        int end = s.length() - 1;
        while (s.charAt(start) == ' ') start++;
        while (s.charAt(end) == ' ') end--;
        StringBuilder sb = new StringBuilder();
        while (start <= end) {
            char c = s.charAt(start);
            if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
                sb.append(c);
            }
            start++;
        }
        // System.out.println("ReverseWords.removeSpace returned: sb = [" + sb + "]");
        return sb;
    }

    /**
     * 反转字符串指定区间[start, end]的字符
     */
    public void reverseString(StringBuilder sb, int start, int end) {
        // System.out.println("ReverseWords.reverseString() called with: sb = [" + sb + "], start = [" + start + "], end = [" + end + "]");
        while (start < end) {
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;
        }
        // System.out.println("ReverseWords.reverseString returned: sb = [" + sb + "]");
    }

    private void reverseEachWord(StringBuilder sb) {
        int start = 0;
        int end = 1;
        int n = sb.length();
        while (start < n) {
            while (end < n && sb.charAt(end) != ' ') {
                end++;
            }
            reverseString(sb, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}

java复制代码//法一：
    public String reverseLeftWords(String s, int n) {
        StringBuilder sb = new StringBuilder();
        sb.append(s.substring(n)+s.substring(0,n));
        return sb.toString();
    }
//法二：
class Solution {
    public String reverseLeftWords(String s, int n) {
        int len=s.length();
        StringBuilder sb=new StringBuilder(s);
        reverseString(sb,0,n-1);
        reverseString(sb,n,len-1);
        return sb.reverse().toString();
    }
     public void reverseString(StringBuilder sb, int start, int end) {
        while (start < end) {
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;
            }
        }
}

java复制代码    public static int strStr(String haystack, String needle) {
        if (needle.equals("")) return 0;//每个题目要求不一样，伺机而动
        if (haystack.length() == 0 || needle.length() == 0 || haystack.length() < needle.length()) return -1;
        char[] str1 = haystack.toCharArray();
        char[] str2 = needle.toCharArray();
        //建立next[i]数组，存储在str2第i个字符前,最长的（前缀和后缀相等）的长度。注意字符串本身不会包括在里面
        int[] next = new int[str2.length];
        next[0] = -1;
        if (str2.length > 1){//防止str2只有一个字符
            next[1] = 0;
        }
        int i = 2;
        //初始cn记录的是next[i- 1]的值，因为这里i的初始是2，所以next[i-1] = 0,所以cn = 0;
        int cn = 0;
        while (i < str2.length){
            if (str2[i - 1] == str2[cn]){
                next[i++] = ++cn;
            }else if (cn == 0){
                next[i++] = 0;
            }else {
                cn = next[cn];
            }
        }
        //利用next[] 数组求解字符串匹配问题
        int t1 = 0; int t2 = 0;
        while (t1 < str1.length && t2 < str2.length){
            if (str1[t1] == str2[t2]){
                t1++;
                t2++;
            }else if (t2 == 0){
                t1++;
            }else {
                t2 = next[t2];
            }
        }
        return t2 == str2.length ? t1 - t2 : -1;
    }

    public static void main(String[] args) {
        String haystack = "abcdeabcfee";
        String needle = "d";
        System.out.println(strStr(haystack,needle));
    }

java复制代码public static boolean repeatedSubstringPattern(String s) {
        if (s.length() < 2) return false;
        //可以利用KMP算法，以为next[]数组中一定会有相应的规律
        char[] arr = s.toCharArray();
        int n = s.length();
        int[] next = new int[n + 1];
        next[0] = -1;
        next[1] = 0;
        int i = 2;
        int cn = 0;
        while (i <= n){
            if (arr[i - 1] == arr[cn]){
                next[i++] = ++cn;
            }else if (cn == 0){
                next[i++] = 0;
            }else {
                cn = next[cn];
            }
        }
        for (int h : next){
            System.out.println(h);
        }
        if (next[n] != 0 && n % (n - (next[n])) == 0){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        String haystack = "abcabcabc";
        System.out.println(repeatedSubstringPattern(haystack));
    }

java复制代码    public static boolean buddyStrings(String s, String goal) {
        int len1 = s.length();
        int len2 = goal.length();
        if (len1 != len2) return false;
        int[] count1 = new int[26];
        int[] count2 = new int[26];
        int dif = 0;
        for(int i = 0; i < len1; i++){
            count1[s.charAt(i) - 'a']++;
            count2[goal.charAt(i) - 'a']++;
            //记录不同的次数
            if (s.charAt(i) != goal.charAt(i)){
                dif++;
                //这里会有一个很大的漏洞，就是如果是aaabb,aaacc就会返回正确，
                //判断的太早了，还需要判断词频是不是一样，就可以杜绝这个现象
//                if (dif > 2) return false;
            }
        }
        //判断词频
        boolean ok = false;
        for (int i = 0; i < 26; i++){
            if (count1[i] != count2[i]) return false;
            //判断谁都一样，保证词频相同的话
            if (count1[i] > 1) ok = true;
        }
        return dif == 2 || (dif == 0 && ok == true);
    }

java复制代码class Solution {
    public String shortestCompletingWord(String licensePlate, String[] words) {
        int[] charNum = new int[26];
        for (int i = 0; i < licensePlate.length(); i++) {
            if (Character.isLetter(licensePlate.charAt(i))) {
                ++charNum[Character.toLowerCase(licensePlate.charAt(i)) - 'a'];
            }
        }
        int len = Integer.MAX_VALUE;
        int idx = -1;
        for (int i = 0; i < words.length; i++){
            int[] charNum2 = new int[26];
            for (int j = 0; j < words[i].length(); j++){
                ++charNum2[words[i].charAt(j) - 'a'];
            }

            boolean ok = true;
            for (int k = 0; k < 26; k++){
                if (charNum[k] > charNum2[k]){
                    ok = false;
                    break;
                }
            }
            if (ok && (idx < 0 || words[i].length() < words[idx].length())){
                idx = i;
            }
        }
        return words[idx];
    }
}