目录
startsWith(String s) endsWith(String s)
str.insert(int index,String s)
str.delete(int startIndex，int endIndex)
str.setCharAt(int index, char ch)
多态
向下转型的前提是父类对象指向子类对象，即在向下转型之前，需要先完成向上转型。
instanceof关键字
instanceof关键字功能在于做强制类型转换之前都会使用该关键字先判断，然后进行转换。判断的对象与指定的类别必须要存在继承或者实现的关系。
内部类
成员内部类
成员内部类是最普通的内部类，它的定义在一个类的内部。它和外部类的其他数据成员和方法是并列存在的。
成员内部类可以访问外部类的所有成员，包括私有成员。
但在外部类中不允许直接访问内部类的成员，若要调用内部类的方法，只能通过实例对象然后访问公有成员。
如：
静态内部类
静态内部类的构造和普通成员类差不多，区别在于静态内部类需要在内部类前增加关键字static。静态内部类不能直接访问外部类的非静态成员，若要访问可以通过 new 外部类().成员 的方式。
如上图，调用外部类的普通成员函数需要加关键字new实例化。
局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类，存在于类的某个局部。
局部内部类和成员内部类的区别在于：局部内部类的访问仅限于所在的方法内或者作用域内。
局部内部类不可使用访问控制修饰符：public，protected和private都不能用。
主函数调用外部类中包含内部类的方法：
匿名内部类
匿名内部类顾名思义就是没有名字的类，它必须是非静态类。匿名内部类在声明时没有自己的构造方法，所以初始化时没有class,interface,implements,extends关键字。匿名类实现前提是只能继承一个类或者实现一个接口。匿名类可以简略很多冗余的代码，使代码更容易维护。匿名内部类的本质其实就是用于继承其他类或是实现接口。
还有一处要注意：匿名内部类访问外部局部变量的时候要用关键字final，否则会编译错误
创建一个类Person调用前面的方法taste
异常
Throwable类是Java异常类型的顶层父类。异常的根类是java.lang.Throwable。
Exception类：这是由程序和外部环境引起的错误，当Exception类发生时开发者应当捕获和处理。它有一个重要的子类名为RuntimeException，包含了所有常见的运行时的异常。当发生Exception异常时，程序可以自身捕获并处理异常。
Error类：内部系统错误，这是由Java虚拟机抛出的，内存不够、虚拟机错误等等。当因这些错误导致程序中断停止时，仅靠修改代码本身是无法进行修复的，更多的建议让用户将程序终止。发生几率罕见。
String类
String存储的字符串内容不可改变
两个字符串连接的方法
1.concat()函数
String str = "123";
String a = str.concat("456");
2.使用加号 将两个字符串连接起来:
String str = "124";
str = str + "456";
charAt()
方法可以返回下标index的字符
String()
equals ()
public boolean equals (String s),相同返回 true 不同返回 false
判断字符串是否与s指定的字符串实体相同
startsWith(String s) endsWith(String s)
regionMatches()
将两个字符串的某一部分进行比较，相同则返回true 不同返回false
compareTo()
正则表达式
验证
public boolean matches(String regex)
正则验证，使用指定字符串判断其是否符合给出的正则表达式结构
替换
1.public String replaceAll(String regex,String replacement)
这个替换方法是把匹配上的所有字符串都进行替换
比如，将一个字符串中的所有数字都替换成123
2.public String replaceFirst(String regex,String replacement)
这个是将匹配到的第一个字符串替换掉
将一个字符串中的第一个数字替换成123
拆分
1.public String[] split(String regex)
将匹配到的所有字符串进行拆分
2.public String[] split(String regex,int limit)
部分分割，参数limit是分割后的字符串的参数
创建字符串
StringBuffer类
对象是字符串,String类对象在创建之后无法更改字符串的内容,StringBuffer类的对象在创建以后可以更改内容。
StringBuffer str = new StringBuffer("hello");
StringBuffer对象的创建不可以像String类一样直接使用双引号。
str.append(s)
在str后面追加s,返回改变以后的StringBuffer对象。str必须是StringBuffer类，参数s可以是String，StringBuffer，int，float等。
append()方法会返回改变后的StringBuffer类，而且调用append()方法的StrinBuffer对象的字符串也会改变。
str.insert(int index,String s)
从下标index开始插入字符串s，返回改变以后的StringBuffer对象
str.delete(int startIndex，int endIndex)
删除str中下标从startIndex到endIndex-1的字符.
str.deleteCharAt(int index)
此方法是删除字符串str中下边为index的字符
str.setCharAt(int index, char ch)
将下标为index的字符替换成ch
str.charAt(index)
取出str中下标为index的字符
Runtime类
每个Java程序都有一个Runtime实例，该类会被自动创建。我们不可以自行创建这个对象的，一般情况下通过Runtime.getRuntime() 方法来获取当前程序的Runtime实例。
maxMemory()
Java平台能够申请到的最大内存
totalMemory()
到运行到当前代码行时，Java平台已经申请到的内存
freeMemory()
行到当前代码行时，这个进程还剩余的内存
System类
System作为系统类,它包含了系统的控制方法和属性，System类的构造器由private修饰，不允许被实例化，类中的方法都是static修饰的静态方法，所以可以直接调用。
arraycopy()
public static void arraycopy(Object src,int srcPos, Object dest,int desPos,int length)
数组拷贝
src - 源数组
srcPos - 源数组中的起始位置
dest - 目标数组
destPos - 目标数据中的起始位置
currentTimeMillis()
public static long currentTimeMillis()
返回当前时间的毫秒值
getProperty(String key)
public static String getProperty(String key)
获取系统属性
Data类
java.util.Date
Date类的构造方法有两个 ：
1.public Date()
创建一个Date对象，并且把当前时间信息存储在此对象中。
要点：这里分配的时间是运行Java程序到此行代码时候的瞬间时间
2.public Date(long date) 根据给定的毫秒值创建日期对象。
比如输入的毫秒值date是1000 【一秒】即 Date d = new Date(1000);
对应的d代表的日期就应该是1970-1-1 08:00:01
Date的方法主要有两个方面作用：
1、日期与毫秒值的相互转换2、比较两个日期的前后顺序
getTime()
public long getTime()
返回当前对象代表的时间的毫秒值
setTime(long time)
public void setTime(long time)
毫秒转日期
设置一个Date对象用来代表从1970年08:00:00开始的一段毫秒级数据后所代表的时间点
例：
Date date = new Date();
date.setTime(1000);
before(Date when)
public boolean before(Date when)
判断当前日期是否在when之前
例：d.before(when)
如果d表示的时间比when表示的时间早 返回true
如果d的时间和when表示的时间相等或者晚 返回false
after(Date when)
public boolean after(Date when)
判断当前日期是否在when之后
当且仅当此 Date 对象表示的瞬间比 when 表示的瞬间晚，才返回 true；否则返回 false。
equals(Date when)
public boolean equals(Date when)
判断当前日期是否与when一样
例：d.equals(when)
当且仅当d表示的时间和when表示的时间相等时返回true，否则返回false
compareTo(Date anotherDate)
public int compareTo(Date anotherDate)
例：d.compareTo(when)
如果参数 when 等于 d表示的时间，则返回值 0
如果d表示的时间 在 when表示的时间 之前，则返回-1
如果d表示的时间 在 when表示的时间 之后，则返回1
Calendar类
java.util.Calendar
Calendar 是专门用于对日期进行操作的类,对Date类进行打印的时候，会出来一长串的日期从年到秒,有时候我们只需要日期中的某一部分信息，比如几月几日，这时Calendar类就可以方便的实现。
Calendar类它为特定时间与一组诸如 YEAR、MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法。
Calendar类的方法主要包括获取、设置、运算三方面。
Calendar类提供了一个类方法getInstance，方便我们获得使用,getInstance()方法返回一个 Calendar()对象,并且该对象的日历字段存储的时间信息已由当前日期、时间初始化。
例：
Calendar cd = Calendar.getInstance();
读取
public int get(int field)
返回给定字段（field）的值
例(读取年份)：
int year = cd.get(Calendar.YEAR);
要点：月份字段MONTH的有效值是0-11 所以实际的月份值应该是月份字段值+1
例：int month = cd.get(Calendar.MONTH) + 1;
设置
Calendar类的设置方法set有若干种形式
计算
public abstract void add(int field, int amount);
对给定的日历字段 field 做加减操作
amount是正数,比如1,3,6就是加
amount是负数，比如-1,-3,-6就是减
要点：这个方法包含了进位、借位功能
SimpleDateFormat类
java.text.SimpleDateFormat
这个类一般用于取出时间的某一个日期信息,这个类和Calendar类不同的是，他可以将取出的信息格式化。
SimpleDateFormat类的方法主要有两方面作用：
1、将date类型的日期信息转化为格式化的字符串内容
2、将格式化的字符串内容转化为date类型的日期信息
例：
Date date = new Date() ;
String time1 = new SimpleDateFormat("y").format(date) ;
parse()
把String型的字符串转换成特定格式的date类型
例：String str = "2018-03-11" ;
Date date = new SimpleDateFormat("yyyy-MM-dd").parse(str) ;
要点1：传入的日期信息有时候只有月份,日期这种部分日历信息
要点2：该方法不使用给定字符串的整个文本，比如例子中 str = "2018-03-11aschd"
要点3：传入的日历信息一定要符合格式
要点4：如果字符串中的时间值超大了，会自动进位.传入的字符串的日历信息是"2018-23-11" ,那和Date对象中的年月日会是2019年11月11日。
Random类
java.util.Random
Random类用于产生随机数
Random类有两个构造方法public Random() 和 public Random(long seed)，这两个构造方法的区别在于随机数种子的选择。
nextBoolean()
public boolean nextBoolean()
生成一个随机的boolean值
nextDouble()
public double nextDouble()
生成一个随机的double值，数值介于[0,1.0)之间
例：
Random r = new Random();
double d = r.nextDouble();
如果要生成其它范围的随机小数，可以在d的结果上进行加减操作
例如生成[1,2.5)区间的小数：
double d_1 = r.nextDouble() * 1.5 + 1;
nextInt();
public int nextInt();
生成-2^31到2^31-1之间int随机数
public int nextInt(int n):
方法中加一个参数n 即可生成[0,n)之间的整数
例：
Random r = new Random();
int d = r.nextInt(3);
nextFloat();
返回float型的随机数，随机数的范围是[0,1.0)
setSeed(long seed)
public void setSeed(long seed)
重新设置种子数
Math类
因为Math类的所有执行方法都是静态方法，所以可以直接使用 类名.方法名 的方式调用，如:Math.max(1,2)
要点：Math类中定义了两个double型常量
PI 和 E：
PI就是数学中π（圆周率）的值 PI = 3.141592653589793;
E 则是e指数底的值 E = 2.718281828459045;
Math类的方法主要为三类：三角函数方法、指数函数方法、服务方法
常用：
包装类
包装类就是基本数据类型的对象表示。对象拥有方法和字段，对象的调用都是通过引用对象的地址，但是基本类型不是，它是直接存储数值的，没有字段、方法这些东西。
Java是面向对象的编程语言，但是，其中的八种基本数据类型并不支持面向对象编程：byte,short,int,long，char,float,double,boolean。这些数据类型没有对象的特性，它们没有字段，也没有方法。
如Java中的集合就不允许存放基本数据类型，这个时候就需要包装类的帮助。
包装类和基本数据类型的对应如下图：
构造方法有两种：
1.将与之对应的基本数据类型作为参数，来构造它们的实例
public Type（type value）
例：Integer i=new Integer(123);
2.将一个字符串作为参数构造它们的实例[除Character类外]
public Type（String value）
例：Integer i=new Integer("123");
要点1.使用字符串作为数字类型的包装类时，字符串不能为空。
要点2.使用字符串作为Boolean类型的包装类时，如果字符串内容为true【不考虑大小写】该对象表示true，如果不是true，那么其它任何参数都表示false。
装箱
两种方式：
1.构造方法
2.valueOf方法
1).所有的包装类都有的方法
public static Type valueOf(type value)
例:Integer i = Integer.valueOf(234);
2).除了Character类以外，其他包装类都有
public static Type valueOf(String s)
例如：
Integer i = Integer.valueOf("678");
拆箱
拆箱一般使用XXXValue方法,XXX指的是对应基本类型的名字【XXX小写】
例如: Integer i = Integer.valueOf(234);
int i_1 = i.intValue();
自动装箱拆箱
自动装箱拆箱的规则：
基本数据类型转字符串
1.使用String类的静态方法valueOf()
例： String str = String.valueOf(3.4f);
2.使用 加号 + 将空字符串和基本数据类型字面值相连
String str = 12345 + "";
3.借助基本数据类型对象的toString()方法
例1：String str = Integer.toString(20);【静态方法】
例2【借助包装类】：
Double d = new Double(425.0);
String str =d.toString();
字符串转基本数据类型
有两种方法：
1.借助基本数据类型对象的静态方法parseXxx()【基本数据类型名字Xxx首字母大写】
例： int i = Integer.parseInt("34264");
2.用字符串构造基本类型的封装对象，再调用封装对象的xxxValue()方法
例子：
Double d = new Double("20.5");
double d_1 = d.doubleValue();
正则表达式
java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现
构造方法:
private Pattern(String p, int f)
通过静态方法compile()创建Pattern对象
例如：Pattern p=Pattern.compile("\\w+");
返回字符串类型的正则表达式
split(CharSequence input)
public String[] split(CharSequence input)
通过正则表达式对input进行分割
matches(String regex, CharSequence input)
public static boolean matches(String regex, CharSequence input)
通过指定的正则表达式regex对input进行正则匹配
要点：这里的matches()方法只能够匹配一次、而且一次就是匹配全部字符串，所以一般适用于快速匹配的情况
如果需要匹配多次这样的匹配操作，可以借助Matcher类的方法完成:public Matcher matcher(CharSequence input)
Matcher类
matches()
public boolean matches()
将整个目标字符串与正则表达式进行匹配
只有完全匹配才能返回true，否则false
lookingAt()
public boolean lookingAt()
目标字符串的起始字符串与正则表达式匹配返回true，否则返回false【如下】
find()
public boolean find()
对字符串进行匹配,匹配到的字符串可以在任何位置【如下】
上面方法匹配完成以后，只能返回true和false这样的信息,start()/ end()/ group()利用这三个方法，我们可以在匹配完成以后得到一些准确的信息。
集合
集合是存储对象的容器，集合中可以存储任意类型的对象,而且长度可变。
集合框架是一个用来表示和操作集合的统一架构，包含实现集合的接口和类。Java的整个集合框架围绕一组标准接口设计，开发者可以直接用，也可以自定义。
集合框架需要包含的三个方面：
1.接口
2.实现类
3.算法
集合框架定义了一组接口：集合Collection和图Map。它们是Java集合框架的根接口，接口申明了对特定类型的集合可以执行的操作
Collection
存储一个元素集合，它的接口有三个子类型分别是List，Set，Queue。
Set代表无序，不可重复集合
List代表有序，可重复集合
Queue代表队列，实现元素先进先出管理。
List，Set，Map的区别
List：
1.可以允许有重复的对象
2.可以插入多个null元素
3.List是一个有序容器，保持了每个元素的插入顺序
4. 常用的实现类有 ArrayList、LinkedList 和 Vector
Set：
1.不允许重复对象
2.只允许一个 null 元素
3.无序容器，不保证每个元素的存储顺序
4.Set最流行的实现类是基于 HashMap 实现的 HashSet
Map：
1.Map是一个接口，不是子接口或实现类
2.Map可以有随意个null值，但最多只能有一个 null键
如果需要经常使用索引来对容器中的元素进行访问，那么可以选择List。
如果需要容器中的元素能够按照它们插入的次序进行有序存储，也选择List
若已知索引，ArrayList可以提供更快速的访问，若需要经常添加删除元素，可以选择LinkedList。
若需要保证插入元素的唯一性，也就是没有重复值的出现，可以选择Set的实现类。
若需要以键和值的形式进行数据存储，那么可以选择Map。
List
对于需要快速插入，删除元素，使用LinkedList
对于需要快速随机访问元素，使用ArrayList
一个一个的填数据
当这个数组被填满，而我们又需要添加新数据时，生成一个新数组，长度是原始长度的两倍。然后如此循环
ArrayList
java.util.ArrayList
①boolean contains(Object o)
查看集合是否包含数据o，返回一个布尔值
②Object[] toArray()
把list转换成长度固定的数组
③add(int index,E element)
在某个位置添加元素
④remove(int index);意思是删除某个位置的元素
⑤remove(Object o);意思是删除元素o
⑥int size() ;获取list当前有几个数据，返回一个整数值
⑦void clear() 清空整个list
⑧get(int index)是很常用的返回第index个元素
LinkedList
内核是链表，是一个双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList随机访问效率低，但随机插入、随机删除效率高
Set
Set特点是：
①不允许重复值的出现
②取值时不保证数据和存入的时候顺序一致
例子：Set<String> set1 = new HashSet<String>();
这里的HashSet是以哈希表的方式实现的，HashSet 线程不安全，存取速度快，且允许存入空值。
方法
①add() 添加数据
②addAll(n) 向set中添加n的所有数据
③remove(Object o) 移除数据
④removeAll(n) 在set中移除n的所有数据
⑤clear() 清空数据
for循环遍历一遍
⑥size() 求set中数据的个数
⑦isEmpty() 判断set是否为空，返回true/false
Map
存储键/值对映射
代表具有映射关系的元素的集合
HashMap
它是最常用的Map,根据键的HashCode值存储数据，存储的内容是键值对(key-value)映射。根据键可以直接获取它的值，有很快的访问速度，HashMap最多只允许一条记录的键为Null(多条会覆盖)，且允许多条记录的值为Null。
注意，HashMap中的映射不是有序的，且它的实现不同步，线程不安全。
HashMap的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。“容量”是指哈希表在创建时的容量，“加载因子”是指当哈希表中的条目数超出了加载因子与当前容量的乘积时，将此时哈希表的容量扩大两倍，默认加载因子是 0.75。
构造方式：
①默认构造函数
② 指定“容量大小”的构造函数
③ 指定“容量大小”和“加载因子”的构造函数
方法：
①put(Object k, Object v) 添加映射
②size() 返回map中映射的个数
添加a-A,b-B两个映射：
③putAll() 从指定映射中将所有映射关系复制到此映射中
比如把m2添加至m1中
④containsKey() 如果此映射包含指定键的映射关系，则返回 true，否则返回false
⑤containsValue() 如果此映射将一个或多个键映射到指定值，则返回 true，否则返回false
比如查找值为0和1的映射
⑥remove() 移除一个映射
比如，移除一个键为three的映射
⑦clear() 从此映射中移除所有映射关系
⑧isEmpty() 如果map为空，则返回 true
vector
vector 是向量类，可实现自动增长的对象数组。它的本质是数组，继承于AbstractList，支持相关的添加，删除，修改，遍历等功能。
创建了一个vector的对象后，可以往其中随意插入不同类的对象，也就是说，不需顾及类型，也不需预先选定向量的容量，并可以方便地进行查找。
对于预先不知道大小的数组，和需要频繁地进行查找，插入，删除工作的情况，可以考虑使用vector。
构造方式
①Vector()
这是默认构造函数
若使用默认构造函数，则Vector的默认容量大小是10。
②Vector(int capacity)
capacity是Vector的容量大小。
当由于增加数据导致容量增加时，每次容量会增加一倍。
③Vector(int capacity, int capacityIncrement)
apacity是Vector的容量大小，capacityIncrement是每次Vector容量增加时的增量值。
④Vector(Collection<? extends E> collection)
意思是创建一个包含collection的Vector
遍历方式
①通过迭代器(Iterator)遍历
迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或者全部元素。
②随机访问，通过索引值去遍历
③使用增强for循环遍历
④Enumeration遍历
方法
①add("x") 代表向vector中添加值为x的数据
②add(index, element) 代表在位置index上插入element，index之后的数据位置依次+1
③set(n, "m") 代表更改位置n的数据为m
④subList(n, m) 意思是获取位置n到m-1的所有数据
⑤顺序查找数据为Object的位置 indexOf(Object)
⑥倒序查找数据为Object的位置 lastIndexOf(Object)
⑦firstElement() 获取第一个元素
⑧lastElement() 获取最后一个元素
⑨elementAt(n) 获取位置n上的元素
⑩获取Vector的大小 size()
⑪获取Vector的总的容量 capacity()
⑫retainAll(x) 判断vec是否包含vec2的值，返回true/false
⑬清空vector，clear() 和 removeAllElements() 是一样的
⑭isEmpty() 判断vector是否为空
泛型
泛型，即“参数化类型”，即将类型由原来的具体类型转向参数化。类似于方法中的变量参数。
定义泛型引用一定要使用尖括号指定类型参数
比如：ArrayList<Integer> list1 = new ArrayList<Integer>();
这里的Integer可以替换成任何类型参数，String、Boolean等等都行，ArrayList也可以替换成任何容器，Map、Set等等都可以。
比如：List<String> list = new List<String>();
它也可以写成：List<String> list = new List<>();
Java的泛型中可以指定一个泛型的上限和下限，范围的上限使用extends关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。范围下限使用super进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object类。如下图：
在泛型类的操作中，在进行传递的时候泛型类型必须匹配才可以传递，如果现在一定要传递，则可以将fun方法中的泛型取消掉：
T用来接收泛型
通配符
通配符用问号？表示，使用？意味着可以接收任意的内容
注意！<?> 只能接收。但是不能修改！
泛型接口
泛型接口定义
泛型方法
例子：
第一个T是声明的自定义泛型
第二个T是返回值类型
gatData是函数名
注意：在泛型中不能使用基本数据类型，如果需要，那就使用基本数据类型对应的包装类型。比如：int i = getData(123);就要写成 Integer i = getData(123);
枚举
枚举是关于常量定义的特殊数据类型
定义枚举类型时，使用关键字enum
例子如下：
enum Day {MONDAY, TUESDAY, WEDNESDAY}
要点： 值一般是大写的字母，多个值之间以逗号分隔
使用：枚举名.常量名，例如 Day.SUNDAY
常见用法
1.switch语句
2.向枚举类型中添加新方法
要点：定义方法时，必须在enum序列的最后添加一个分号
3.覆盖枚举的方法
enum类的父类Enum中的定义的方法只有toString()方法没有被final修饰,所以也只能覆盖toString()方法
4.实现接口
要点：所有的枚举都继承自java.lang.Enum类,枚举对象不能再继承其他类
5.使用接口组织枚举
注解
一、Java自带的标准注解
1.@Override : 标明重写某个方法
现在要重写父类中的一个方法，就可以在该方法前进行注解，这样编译器就会验证@Override下面的方法名是否是你父类中所有的,如果没有则报错。
2.@Deprecated : 标记过时的元素
当开发者调用了一个过时的元素（方法、类、成员）时，编译器会发出警告，提醒开发者该元素已过时：
3.@SuppressWarnings 标明要忽略的警告
二、常用元注解
三、自定义注解
自定义注解即根据自己的需求定义注解
多线程
多线程是指在同一程序中有多个顺序流在执行。
用Java语言进行开发时，在 Java 的开发环境下启动 JVM，就表示启动了一个进程。
每个进程对应一定的内存地址空间，并且只能使用它自己的内存空间。
一个进程可以启动多个线程，并且同一个进程中的线程共享其进程中的内存和资源。
创建线程
通过继承Thread类
Thread类是非常重要的线程类，它实现了Runnable接口
Runnable接口提供了一个独立线程的运行机制。实现该接口，就可以根据情况启动一个独立线程进行工作，是并行与main线程的。
用start()来启动线程，同一个线程对象实例不能启动两次。
通过实现Runnable接口
同步锁
即有synchronized关键字修饰的方法，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
使用格式：public synchronized void 方法名(){}，只需要在有可能发生资源冲突的方法，前面加上synchronized即可。
同步代码块
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
synchronized(对象){}
因为同步是一种高开销的操作，通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可
设置优先级
getPriority()方法
1为最低优先级，10位最高优先级
Thread.yield()
方法作用是:暂停当前正在执行的线程对象，并执行其他线程。
调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。
yield不能控制具体的交出CPU的时间，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
402
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
