前提：有一个线程的执行主类

要实现一个多线程的主类：

每一个

1.继承一个Thread类：

继承Tread类并且覆写一个run方法

Example:

class MyThread extends Thread{
    private String title;
    public MyThread(String title){
        this.title=title;
    }
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(title+" : "+i);
        }
    }
}

public class Test {

    public static void main(String args[]) {
        MyThread m1= new MyThread("Thread1");
        MyThread m2= new MyThread("Thread2");
        MyThread m3= new MyThread("Thread3");
        
        m3.start();
        m2.start();
        m1.start();
    }
}

2.（推荐）实现Runnable、Callable接口

线程阻塞：所有的代码都在main方法里面，如果列出不完成，后面的代码不能继续执行。要想解决这种线程的阻塞，那么最好再产生一个新的线程。

FIle里面有一系列取得文件信息的方法。

1.判断路径是否是文件：isFile

2.判断路径是否是目录：isDirectory

3.取得文件大小：length  

4.最后一次修改日期：lastModified()

ListFiles(): 列出目录中的结构组成。

1.取得父路径： File getParentFile();

创建目录：mkdir()只创建一级

mkdirs()不管有多少级，都帮你创建

如果创建文件要先判断目录时候存在。

File类的基本使用：

两个构造方法

1.File(String pathname)

2.File(File parent ,String child)设置父路径和子路径。

要想对文件进行基本操作，可以使用如下的方法：

1.创建一个新文件：createNewFile()

File类只是创建文件，对其内容并不负责。

2.删除文件：delete()

2.判断文件是否存在：exists()

在java里面如果要进行文件的处理操作是要通过本地操作系统支持的，如果操作的是同名文件，就会出现过延迟问题。最好是找不同命操作。

String类对正则的支持

matches（）：进行字符串验证，匹配某个正则

replaceAll（）：替换所有

split（）：根据正则拆分

数字验证：

1.不管整数还是小数，变为double

\\d+(\\.\\d)?

2.一个字符串是否是日期或者日期时间：

\\d{4}-\\d{2}-\\d{2}

这种正则的格式判断最后分开

3.判断给定的电话号码是否正确（用一个正则）

格式1：51283346   \\d{7,8}

格式2：01051283346  (\\d{3,4})?\\d{7,8}

个是3：（010）-51283346 

((\\(\\d{3,4}\\)-)|(\\d{3,4}))?\\d{7,8}

4.验证emali地址

简单验证：字母数字，下划线组成

\\w+@\\w+.\\w+

复杂的：用户名必须由字母开头，而且组成可以是字母，数字，_,-,.组成，用户名长度必须在6到15位之间，后缀必须是.com，.net，.cn，.org，.gov，.com.cn，.net.cn

[a-zA-z]   [a-zA-Z\\-_\\.0-9]{5,14}  @  [a-zA-Z\\-_\\.0-9]+   \\.  (com|net|org|gov)

进程：在操作系统中，一个程序的执行周期就称为一个进程。

在同一个时间段上可以有多个进程同时执行，但在同一个时间点上只会有一个进程执行。

线程是进程的最小单元，进程比线程慢

每一个用户就是一个线程，每一个线程上有独立的对象

高并发：线程量暴涨，服务器的内存不够用了，无法处理新的用户

线程是在进程上的划分，没有进程就没有线程

Lamdba语法实际上简化为了方法引用，但其核心在于函数式编程。函数式接口有四种：

功能型函数式接口(输入一个数据，在数据处理后再输出)：

如果现在确定操作的数据是int,则可以使用IntFunction;

public interface Function<T,R> {public R apply(T t);};

For example:

public class Test {

    public static void main(String args[]) {
        Function<Integer,String> iu=String::valueOf;
        System.out.println(iu.apply(100));
        
    }
}

供给型函数接口：

Interface Supplier<T> {public T get();};

For example:

public class Test {

    public static void main(String args[]) {
        Supplier<String> cons="hello"::toUpperCase;
        System.out.println(cons.get());
        
    }
}

消费型函数

pulic interface Consumer<T>{public void accept(T t);};

For example:

public class Test {

    public static void main(String args[]) {
        Consumer<String> cons=System.out::println;
        cons.accept("Hello World!");
        
    }
}

断言型函数接口

public interface Predicate<T>{boolean test(T t);};

For example:

public class Test {

    public static void main(String args[]) {
        Predicate<String> pre = "##hello"::startsWith;
        System.out.println(pre.test("##"));
        
    }
}

进行引用基本上都是针对引用类型完成的--》只有数组、类、接口具有引用的操作，现追加方法的引用也是别名的引用

1.引用静态方法：类名称：：static方法名称

package t.com.util;

interface IUtil<P,R>{
    public R transform(P p);
}

public class Test {

    public static void main(String args[]) {
        IUtil<Integer,String> iu=String :: valueOf;
        String s=iu.transform(1000);
        System.out.println(s.length());
        
    }
}

2.引用某个对象的方法：实例化对象：：普通方法名称

package t.com.util;

interface IUtil<R>{
    public R transform();
}

public class Test {

    public static void main(String args[]) {
        IUtil<String> iu="Hello":: toUpperCase;
        System.out.println(iu.transform());
        
    }
}

3.引用某个特定类的方法：类名称：：普通方法

interface IUtil<R,P>{
    public R compare(P p1,P p2);
}

public class Test {

    public static void main(String args[]) {
        IUtil<Integer,String> iu=String:: compareTo;
        System.out.println(iu.compare("H","h"));
        
    }
}

4.引用构造方法：类名称：：new。

class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
    
}

interface IUtil<R,P,F>{
    public R create(P p,F F);
}

public class Test {

    public static void main(String args[]) {
        IUtil<Person,String,Integer> iu=Person:: new;
        System.out.println(iu.create("Marry",20));
        
    }
}

正则标记：

1.描述某一个字符：X

2.\\:匹配“\”

3.\n换行

1.[abc]:表示可能是字幕a、b、c中的任意一个

2.[^abc]：表示不是字幕a、b、c中的任意一个

3.[0-9]:表示字符的0到

4.[a-zA-Z]：由字母组成，大小写任意

1.“.”:表示任意的一位字符

2.\d:等价于[0-9],表示任意一位数字

3.\D:等价于“[^0-9]”表示任意的非数字

4.\s：表示是一个空格。

5.\S:表示不是一个空格

6.\w：等价于“[a-zA-Z0-9_]”,表示字母、数字、下划线组成。

7.\W：等价于“[^a-zA-Z0-9_]”

数量表达式：

正则？：表示一次或者0次

正则+：表示一次或者多次

正则*：表示一次，0次或者多次

正则{n}:表示该匹配出现正好n次

正则{n,}表示改匹配出现n次以上，包括n次

正则{n,m}:表示该匹配出现n到m次

逻辑匹配：

1.正则A正则B：表示与的关系，在第一个匹配之后立即匹配第二个

2.正则A|正则B：表示A或者B只出现一次

正则表达式：

ThreadLocal可以减少一些重要的引用传递。

观察者设计模式：可以理解为一触即发。如果要想实现这么模式需要两个程序结构：

1.Observer(接口):观察者

2.Observable（类）:被观察者

这种设计模式已经很久不用了，理解一种设计模式。

日期格式化：SimpleDateFormat().

String str="yyyy-MM-dd HH:mm:ss.SSS";

Date date = new Date();

SimpleDateFormat sdf = new SimpleDateFormat(Str);

String val = sdf.format(date);

String str ="1911-11-11 11:11:11.111";

String pat="yyyy-MM-dd HH:mm:ss.SSS";

SimpleDateFormat sdf = new SimpleDateFormat(pat);

Date date = sdf.parse(str);

Date类：直接new Date()取得当前日期时间。

long可以描述Date（）类，

将long变为Date型数据，public Date(long date)

将Date变为long型数据：getTime().

请解释final，finally，finalize的区别：

final：是一个关键字，用于定义不能被继承的父类，不能被覆写的方法，常量

finally：是异常处理的同意出口

finalize：是object中的一个方法，用于在对象回收钱调用。

RunTime类是一个运行时的描述类，在每一个jvm的进程之中都会存在一个runtime的对象。

gc()：执行垃圾回收处理。

什么叫gc()，如何处理：

gc：垃圾收集器，释放无用的垃圾。

gc：一种自动不定期调用，二是使用runtime类中的gc()方法。

String类特点：

任何的字符串常量都是String对象，而且String的常量一旦声明则不可改变。如果改变对象的内容改变的是其引用的指向而已。

String与StringBuffer最大的区别：String的内容我们无法修改，而我们的StringBuffer允许修改。但是一般优先选择String类，只有在频繁修改时才用到StringBuffer。

String，StringBuffer，StringBuilder的区别：

String的内容不可修改，而后两者可以修改。

后两者的区别：StringBuffer采用我们的同步处理，属于线程安全操作，而StringBuilder采用异步处理，属于线程不安全操作。

线程池带来的好处：允许多个线程按照组的模式进行程序的处理，这样在某一个业务逻辑复杂的情况下，性能就能很好的提升。