第十三章:StringTable
- String的基本特性
- 为什么JDK9改变了结构
- String的不可变性
- 面试题
- 注意
- String的内存分配
- 为什么StringTable从永久代调整到堆中
- String的基本操作
- 字符串拼接操作
- 拼接操作和append性能对比
- intern()的使用
- intern的空间效率测试
- 面试题
- new String("ab")会创建几个对象
- new String("a") + new String("b") 会创建几个对象
- 面试题:intern() 的使用
- JDK6中
- JDK7/JDK8 中
- 扩展
- 总结
- 练习
- StringTable的垃圾回收
- G1中的String去重操作
- 描述
- 实现
- 开启
String的基本特性
- String:字符串,使用一对 ”” 引起来表示
- String s1 = “mogublog” ; // 字面量的定义方式
- String s2 = new String(“moxi”);
- string声明为final的,不可被继承
- String实现了Serializable接口:表示字符串是支持序列化的。实现了Comparable接口:表示string可以比较大小
- string在jdk8及以前内部定义了final char[] value用于存储字符串数据。JDK9时改为byte[]
为什么JDK9改变了结构
String类的当前实现将字符存储在char数组中,每个字符使用两个字节(16位)。从许多不同的应用程序收集的数据表明,字符串是堆使用的主要组成部分,而且,大多数字符串对象只包含拉丁字符。这些字符只需要一个字节的存储空间,因此这些字符串对象的内部char数组中有一半的空间将不会使用。
我们建议改变字符串的内部表示clasš从utf - 16字符数组到字节数组+一个encoding-flag字段。新的String类将根据字符串的内容存储编码为ISO-8859-1/Latin-1(每个字符一个字节)或UTF-16(每个字符两个字节)的字符。编码标志将指示使用哪种编码。
结论:String再也不用char[] 来存储了,改成了byte [] 加上编码标记,节约了一些空间
// 之前
private final char value[];
// 之后
private final byte[] value
同时基于String的数据结构,例如StringBuffer和StringBuilder也同样做了修改
String的不可变性
String:代表不可变的字符序列。简称:不可变性。
当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值。
当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
当调用string的replace()方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
通过字面量的方式(区别于new)给一个字符串赋值,此时的字符串值声明在字符串常量池中。
代码
/*** String的不可变性** @author: Y* @create: 2020-07-11-8:57*/
public class StringTest1 {public static void test1() {// 字面量定义的方式,“abc”存储在字符串常量池中String s1 = "abc";String s2 = "abc";System.out.println(s1 == s2);s1 = "hello";System.out.println(s1 == s2);System.out.println(s1);System.out.println(s2);System.out.println("----------------");}public static void test2() {String s1 = "abc";String s2 = "abc";// 只要进行了修改,就会重新创建一个对象,这就是不可变性s2 += "def";System.out.println(s1);System.out.println(s2);System.out.println("----------------");}public static void test3() {String s1 = "abc";String s2 = s1.replace('a', 'm');System.out.println(s1);System.out.println(s2);}public static void main(String[] args) {test1();test2();test3();}
}
运行结果
true
false
hello
abc
----------------
abc
abcdef
----------------
abc
mbc
面试题
/**** Author: YZG* Date: 2022/10/11 11:03* Description: 演示字符串不可改变*/
public class StringExer {String str = new String("good");char[] ch = {'t', 'e', 's', 't'};// 这里的 str 会重新开辟一个空间,指向 good ,在执行过程中新开辟的 str 重新指向 test ok,原来的 str 并没有修改,还是指向了 goodpublic void change(String str, char ch[]) { str = "test ok";ch[0] = 'b';}public static void main(String[] args) {StringExer ex = new StringExer();ex.change(ex.str, ex.ch);System.out.println(ex.str);//goodSystem.out.println(ex.ch);//best}
}
输出结果
good
best
注意
字符串常量池是不会存储相同内容的字符串的
String的string Pool是一个固定大小的Hashtable,默认值大小长度是1009。如果放进string Pool的string非常多,就会造成Hash冲突严重,从而导致链表会很长,而链表长了后直接会造成的影响就是当调用string.intern时性能会大幅下降。
使用-XX:StringTablesize
可设置stringTab1e的长度
在jdk6中stringTable是固定的,就是1009的长度,所以如果常量池中的字符串过多就会导致效率下降很快。stringTablesize设置没有要求
在jdk7中,stringTable的长度默认值是60013,
在JDK8中,StringTable可以设置的最小值为1009
String的内存分配
在Java语言中有8种基本数据类型和一种比较特殊的类型string。这些类型为了使它们在运行过程中速度更快、更节省内存,都提供了一种常量池的概念。
常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的,string类型的常量池比较特殊。它的主要使用方法有两种:
- 比如:string info=“atguigu.com”; 直接使用 “”
- 使用 String 提供的 intern() 方法
Java 6及以前,字符串常量池存放在永久代
Java 7中 oracle的工程师对字符串池的逻辑做了很大的改变,即将字符串常量池的位置调整到Java堆内
所有的字符串都保存在堆(Heap)中,和其他普通对象一样,这样可以让你在进行调优应用时仅需要调整堆大小就可以了。
字符串常量池概念原本使用得比较多,但是这个改动使得我们有足够的理由让我们重新考虑在Java 7中使用string.intern()
Java8元空间,字符串常量在堆
JDK8的时候,元空间大小只受物理内存影响
为什么StringTable从永久代调整到堆中
在JDK 7中,interned字符串不再在Java堆的永久生成中分配,而是在Java堆的主要部分(称为年轻代和年老代)中分配,与应用程序创建的其他对象一起分配。此更改将导致驻留在主Java堆中的数据更多,驻留在永久生成中的数据更少,因此可能需要调整堆大小。由于这一变化,大多数应用程序在堆使用方面只会看到相对较小的差异,但加载许多类或大量使用字符串的较大应用程序会出现这种差异。intern()方法会看到更显著的差异。
- 永久代的默认比较小
- 永久代垃圾回收频率低
String的基本操作
Java语言规范里要求完全相同的字符串字面量,应该包含同样的Unicode字符序列(包含同一份码点序列的常量),并且必须是指向同一个String类实例。
字符串拼接操作
常量与常量的拼接结果在常量池,原理是编译期优化
常量池中不会存在相同内容的变量
字符串拼接中,只要其中有一个是变量,结果就在堆中。变量拼接的原理是StringBuilder
如果拼接的结果调用intern()方法,则主动将常量池中还没有的字符串对象放入池中,并返回此对象地址。如果有该字符串,则返回有的那个地址
- 常量与常量的拼接结果在常量池,原理是编译期优化
@Testpublic void test1(){String s1 = "a" + "b" + "c";//编译期优化:等同于"abc"。保存在字符串常量池中String s2 = "abc"; //"abc"一定是放在字符串常量池中,将此地址赋给s2/** 最终.java编译成.class,再执行.class* String s1 = "abc";* String s2 = "abc"*/System.out.println(s1 == s2); //trueSystem.out.println(s1.equals(s2)); //true}
其中 s1 在编译阶段将拼接工作完成了,变成 abc
- 常量池中不会存在相同内容的变量
public class StringTest01 {public static void main(String[] args) throws IOException {System.out.println("1"); // 2334System.out.println("2"); // 2336. 还有一个换行符System.out.println("3"); // 2337System.out.println("4"); // 2338// 以下字符串不会保存到常量池中,而是指向存在的字符串。System.out.println("1"); // 2339System.out.println("2"); // 2339System.out.println("3"); // 2339System.out.println("4"); // 2339}
}
- 字符串拼接中,只要其中有一个是变量,结果就在堆中。变量拼接的原理是StringBuilder
@Testpublic void test3(){String s1 = "a";String s2 = "b";String s3 = "ab";/*如下的s1 + s2 的执行细节:(变量s是我临时定义的)① StringBuilder s = new StringBuilder();② s.append("a")③ s.append("b")④ s.toString() --> 约等于 new String("ab")补充:在jdk5.0之后使用的是StringBuilder,在jdk5.0之前使用的是StringBuffer*/String s4 = s1 + s2;//System.out.println(s3 == s4);//false}
如果在字符串拼接过程中出现了变量,则相当于在堆空间中 new String(), 具体内容为拼接结果
通过字节码方式看一下实现细节:
在 Jdk 5.0 之前使用的是 StringBuffer,之后使用 StringBuilder
String | StringBuffer | StringBuilder |
---|---|---|
String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且浪费大量优先的内存空间 | StringBuffer是可变类,和线程安全的字符串操作类,任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量,当字符串大小没有超过容量时,不会分配新的容量,当字符串大小超过容量时,会自动增加容量 | 可变类,速度更快 |
不可变 | 可变 | 可变 |
线程安全 | 线程不安全 | |
多线程操作字符串 | 单线程操作字符串 |
- 如果拼接的结果调用intern()方法,则主动将常量池中还没有的字符串对象放入池中,并返回此对象地址。如果有该字符串,则返回有的那个地址
@Testpublic void test2(){String s1 = "javaEE";String s2 = "hadoop";String s3 = "javaEEhadoop";String s4 = "javaEE" + "hadoop";//编译期优化//如果拼接符号的前后出现了变量,则相当于在堆空间中new String(),具体的内容为拼接的结果:javaEEhadoop// 因此每一个 new 的对象,他的引用地址都是不一样的。String s5 = s1 + "hadoop";String s6 = "javaEE" + s2;String s7 = s1 + s2;System.out.println(s3 == s4);//trueSystem.out.println(s3 == s5);//falseSystem.out.println(s3 == s6);//falseSystem.out.println(s3 == s7);//falseSystem.out.println(s5 == s6);//falseSystem.out.println(s5 == s7);//falseSystem.out.println(s6 == s7);//false//intern():判断字符串常量池中是否存在javaEEhadoop值,如果存在,则返回常量池中javaEEhadoop的地址;//如果字符串常量池中不存在javaEEhadoop,则在常量池中加载一份javaEEhadoop,并返回次对象的地址。String s8 = s6.intern();System.out.println(s3 == s8);//true}
- final 修饰的 字符串变量 称为 常量,则仍然使用 编译前优化。
/*1. 字符串拼接操作不一定使用的是StringBuilder!如果拼接符号左右两边都是字符串常量或常量引用,则仍然使用编译期优化,即非StringBuilder的方式。2. 针对于final修饰类、方法、基本数据类型、引用数据类型的量的结构时,能使用上final的时候建议使用上。*/@Testpublic void test4(){// 加上 final 变成常量final String s1 = "a";final String s2 = "b";String s3 = "ab";String s4 = s1 + s2;System.out.println(s3 == s4);//true}
拼接操作和append性能对比
public static void method1(int highLevel) {String src = "";for (int i = 0; i < highLevel; i++) {src += "a"; // 每次循环都会创建一个StringBuilder、String 对象}}public static void method2(int highLevel) {StringBuilder sb = new StringBuilder(); // 自始至终都只有一个 StringBuilder 对象for (int i = 0; i < highLevel; i++) {sb.append("a");}}
方法1耗费的时间:4005ms,方法2消耗时间:7ms
结论:
- 通过StringBuilder的append()方式添加字符串的效率,要远远高于String的字符串拼接方法
原因:
- StringBuilder的append的方式,自始至终只创建一个StringBuilder的对象
- 对于字符串拼接的方式,还需要创建很多StringBuilder对象和 调用toString时候创建的String对象
- 内存中由于创建了较多的StringBuilder和String对象,内存占用过大,如果进行GC那么将会耗费更多的时间
改进的空间
- 我们使用的是StringBuilder的空参构造器,默认的字符串容量是16,然后将原来的字符串拷贝到新的字符串中, 我们也可以默认初始化更大的长度,减少扩容的次数
StringBuilder s = new StringBuilder(highLevel); //new char[highLevel]
intern()的使用
intern是一个native方法,调用的是底层C的方法
字符串池最初是空的,由String类私有地维护。在调用intern方法时,如果池中已经包含了由equals(object)方法确定的与该字符串对象相等的字符串,则返回池中的字符串。否则,该字符串对象将被添加到池中,并返回对该字符串对象的引用。
如果不是用双引号声明的string对象,可以使用string提供的intern方法:intern方法会从字符串常量池中查询当前字符串是否存在,若不存在就会将当前字符串放入常量池中。
比如:
String myInfo = new string("I love atguigu").intern();
也就是说,如果在任意字符串上调用string.intern方法,那么其返回结果所指向的那个类实例,必须和直接以常量形式出现的字符串实例完全相同。因此,下列表达式的值必定是true
("a"+"b"+"c").intern()=="abc"
通俗点讲,Interned string就是确保字符串在内存里只有一份拷贝,这样可以节约内存空间,加快字符串操作任务的执行速度。注意,这个值会被存放在字符串内部池(String Intern Pool)
intern的空间效率测试
我们通过测试一下,使用了intern和不使用的时候,其实相差还挺多的
/*** 使用Intern() 测试执行效率* @author: YZG* @create: 2020-07-11-15:19*/
public class StringIntern2 {static final int MAX_COUNT = 1000 * 10000;static final String[] arr = new String[MAX_COUNT];public static void main(String[] args) {Integer [] data = new Integer[]{1,2,3,4,5,6,7,8,9,10};long start = System.currentTimeMillis();for (int i = 0; i < MAX_COUNT; i++) {arr[i] = new String(String.valueOf(data[i%data.length])).intern();}long end = System.currentTimeMillis();System.out.println("花费的时间为:" + (end - start));try {Thread.sleep(1000000);} catch (Exception e) {e.getStackTrace();}}
}
结论:对于程序中大量使用存在的字符串时,尤其存在很多已经重复的字符串时,使用intern()方法能够节省内存空间。
大的网站平台,需要内存中存储大量的字符串。比如社交网站,很多人都存储:北京市、海淀区等信息。这时候如果字符串都调用intern() 方法,就会很明显降低内存的大小。
面试题
new String(“ab”)会创建几个对象
@Testpublic void method01() {String s = new String("ab");}
我们转换成字节码来查看
0 new #2 <java/lang/String>3 dup4 ldc #3 <ab>6 invokespecial #4 <java/lang/String.<init>>9 astore_1
10 return
这里面就是两个对象
- 一个对象是:new关键字在堆空间中创建
- 另一个对象:字符串常量池中的对象
new String(“a”) + new String(“b”) 会创建几个对象
@Testpublic void method02(){String s = new String("a") + new String("b");}
字节码文件为
0 new #2 <java/lang/StringBuilder>3 dup4 invokespecial #3 <java/lang/StringBuilder.<init>>7 new #4 <java/lang/String>
10 dup
11 ldc #5 <a>
13 invokespecial #6 <java/lang/String.<init>>
16 invokevirtual #7 <java/lang/StringBuilder.append>
19 new #4 <java/lang/String>
22 dup
23 ldc #8 <b>
25 invokespecial #6 <java/lang/String.<init>>
28 invokevirtual #7 <java/lang/StringBuilder.append>
31 invokevirtual #9 <java/lang/StringBuilder.toString>
34 astore_1
35 return
一共创建了6个对象:
- 对象1:new StringBuilder()
- 对象2:new String(“a”)
- 对象3:常量池的 a
- 对象4:new String(“b”)
- 对象5:常量池的 b
- 对象6:toString中会创建一个 new String(“ab”)
- 调用 toString 方法,不会在常量池中生成 “ab” 对象
对应关系:
面试题:intern() 的使用
分析一下运行结果:
public class StringTest04 {public static void main(String[] args) {String s = new String("1");s.intern();String s2 = "1";System.out.println(s == s2);String s3 = new String("1") + new String("1");s3.intern();String s4 = "11";System.out.println(s3 == s4);}
}
此面试题在不同 JDK 版本中,有不同的答案,主要是由于 JDK 6 7 8 中 字符串常量池的变化。
JDK6中
输出结果
false
false
第一个false:
首先在执行 String s = new String(“1”); 时 会创建俩个对象, 一个在堆一个在字符串常量池,而 s 变量保存的是 堆空间的地址
此时 s.intern 并没有什么作用,因为在这之前字符串常量池就已经有 1 了。
s2 变量指向 字符串常量池。一个对象,一个是常量显然是 false
如果是下面这样的,那么就是true
String s = new String("1");
// 此时 s 将指向字符串常量池中 1 的地址
s = s.intern();
String s2 = "1";
System.out.println(s == s2); // true
第二个false:
首先执行 String s3 = new String(“1”) + new String(“1”); 时,最终 toString 会在堆中创建一个 new String(“11”) 的对象,但是字符串常量池中并没有 11 这个常量。此时 s3 指向 堆空间的 new String(“11”) 对象地址
s3.intern(); 执行此行代码,会在字符串常量池中 创建 11 常量。
String s4 = “11”; s4 指向字符串常量池 的 11 常量地址,这个 11 常量是上面 s3.intern(); 创建的。
因此一个指向堆空间,一个指向字符串常量池,显示也是 false
JDK7/JDK8 中
输出结果:
false
true
第一个false 就和上面分析的一样,一个指向堆,一个指向字符串常量池。
第二个 true:
首先执行 String s3 = new String(“1”) + new String(“1”); 时,最终 toString 会在堆中创建一个 new String(“11”) 的对象,但是字符串常量池中并没有 11 这个常量。此时 s3 指向 堆空间的 new String(“11”) 对象地址
s3.intern(); 执行此行代码,就不会创建 11 这个常量了,而是保存堆空间中 new String(“11”) 这个引用的地址,主要目的是节省内存空间。。
String s4 = “11”; s4 指向字符串常量池中 new String(“11”) 的引用地址,等于 s3
扩展
如果将上面的代码改成以下内容,有什么变化:
String s3 = new String("1") + new String("1");
String s4 = "11";
s3.intern();
System.out.println(s3 == s4);
输出结果:
false
String s4 = “11”; 此时 11 就不再是引用,不在保存 new String(“11”) 的地址,而是正常的一个 常量。
总结
总结string的 intern()的使用:
JDK1.6中,将这个字符串对象尝试放入串池。
- 如果串池中有,则并不会放入。返回已有的串池中的对象的地址
- 如果没有,会把此对象复制一份,放入串池,并返回串池中的对象地址
JDK1.7起,将这个字符串对象尝试放入串池。
- 如果串池中有,则并不会放入。返回已有的串池中的对象的地址
- 如果没有,则会把对象的引用地址复制一份,放入串池,并返回串池中的引用地址
练习
// 练习 public void practise(){String s = new String("a") + new String("b");String s2 = s.intern();System.out.println(s2 == "ab");System.out.println(s == "ab");}
输出结果:
jdk1.6: true false
jdk1.7及以后: true true
JDK 6
String s = new String(“a”) + new String(“b”); 指向堆中的 new String(“ab”) 对象
String s2 = s.intern(); 在字符串常量池中创建 “ab” 常量,并将 “ab” 的地址返回,此时 s2 保存的就是 “ab” 的地址
JDK7/8
String s = new String(“a”) + new String(“b”); 指向堆中的 new String(“ab”) 对象
String s2 = s.intern(); 会将堆中的 new String(“ab”) 对象的地址复制到 字符串常量池中。因此 s2 间接的也指向了 new String(“ab”) 对象
变形:
// 练习@Testpublic void practise(){String x = "ab"; // 变形String s = new String("a") + new String("b");String s2 = s.intern();System.out.println(s2 == "ab"); System.out.println(s == "ab");}
输出结果:
jdk6/7/8 都是 true false
String x = “ab”; 此时增加这行代码后, 字符串常量池中 “ab” 不再是保存 引用,只是一个普通的 常量
因此 s2 = “ab” = x
StringTable的垃圾回收
/*** String的垃圾回收* -Xms15m -Xmx15m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails* @author: YZG* @create: 2020-07-11-16:55*/
public class StringGCTest {public static void main(String[] args) {for (int i = 0; i < 100000; i++) {String.valueOf(i).intern();}}
}
G1中的String去重操作
注意这里说的重复,指的是在堆中的数据,而不是常量池中的,因为常量池中的本身就不会重复
描述
背景:对许多Java应用(有大的也有小的)做的测试得出以下结果:
堆存活数据集合里面string对象占了25%
堆存活数据集合里面重复的string对象有13.5%
string对象的平均长度是45
许多大规模的Java应用的瓶颈在于内存,测试表明,在这些类型的应用里面,Java堆中存活的数据集合差不多25%是string对象。更进一步,这里面差不多一半string对象是重复的,重复的意思是说:
stringl.equals(string2)= true。堆上存在重复的string对象必然是一种内存的浪费。这个项目将在G1垃圾收集器中实现自动持续对重复的string对象进行去重,这样就能避免浪费内存。
实现
- 当垃圾收集器工作的时候,会访问堆上存活的对象。对每一个访问的对象都会检查是否是候选的要去重的string对象。
- 如果是,把这个对象的一个引用插入到队列中等待后续的处理。一个去重的线程在后台运行,处理这个队列。处理队列的一个元素意味着从队列删除这个元素,然后尝试去重它引用的string对象。
- 使用一个hashtab1e来记录所有的被string对象使用的不重复的char数组。当去重的时候,会查这个hashtable,来看堆上是否已经存在一个一模一样的char数组。
- 如果存在,string对象会被调整引用那个数组,释放对原来的数组的引用,最终会被垃圾收集器回收掉。
- 如果查找失败,char数组会被插入到hashtable,这样以后的时候就可以共享这个数组了。
开启
命令行选项
UsestringDeduplication(bool):开启string去重,默认是不开启的,需要手动开启。
Printstringbeduplicationstatistics(bool):打印详细的去重统计信息
stringpeduplicationAgeThreshold(uintx):达到这个年龄的string对象被认为是去重的候选对象
各位彭于晏,如有收获点个赞不过分吧…✌✌✌
第十三章:StringTable相关推荐
- 谭浩强《C++程序设计》书后习题 第十三章-第十四章
2019独角兽企业重金招聘Python工程师标准>>> 最近要复习一下C和C++的基础知识,于是计划把之前学过的谭浩强的<C程序设计>和<C++程序设计>习题 ...
- python 教程 第十三章、 特殊的方法
第十三章. 特殊的方法 1) 特殊的方法 __init__(self,...) 这个方法在新建对象恰好要被返回使用之前被调用. __del__(self) 恰好在对象要被删除之前调用. __st ...
- 《Java编程思想》读书笔记 第十三章 字符串
<Java编程思想>读书笔记 第十三章 字符串 不可变String String对象是不可变的,每一个看起来会修改String值的方法,实际上都是创建一个全新的String对象,以及包含修 ...
- 第十三章、facl及用户及Linux终端
第十三章.facl及用户及Linux终端 08_01_facl及用户及Linux终端 文件系统访问列表: 如何让tom的文件被jerry读写? 用户名:tom, 基本组:tom 1. 添加jerry访 ...
- 第十三章 簇-机器学习老师板书-斯坦福吴恩达教授
第十三章 簇 13.1 无监督学习介绍 13.2 K-均值算法 13.3 优化目标 13.4 随机初始化 13.5 选择簇的数量 13.1 无监督学习介绍 13.2 K-均值算法 13.3 优化目标 ...
- 鸟哥的Linux私房菜(服务器)- 第十三章、文件服务器之一:NFS 服务器
第十三章.文件服务器之一:NFS 服务器 最近更新日期:2011/07/27 NFS为 Network FileSystem 的简称,它的目的就是想让不同的机器.不同的操作系统可以彼此分享个别的档案啦 ...
- 数字图像处理:第二十三章 基于内容的图象与视频检索
第二十三章基于内容的图象与视频检索 目录 1. 引言 2. 基于内容检索的图象特征 3. 基于内容的视频标注与检索 作业 1. 引言 随着社会的信息化发展日益深入,互连网日益普及,越 ...
- 数字图像处理:第十三章 图象复原
第十三章 图象复原 目录 1. 引言 2. 数学模型 3. 维纳滤波(Wiener Filtering) 作业 1. 引言 图象复原是早期图象处理的主要内容之一,目的在于消除或减轻 ...
- [转]Windows Shell 编程 第十三章 【来源:http://blog.csdn.net/wangqiulin123456/article/details/7988004】...
第十三章 Windows脚本环境 现在的许多开发人员以前都是在MS-DOS环境下编程的.几乎所有人都接触过批处理文件--一种基于文本命令的文件.这种文件使你能够在一个可执行命令中组合多个指令.批处理文 ...
- stm32 ucosii消息队列 串口_正点原子STM32F407探索者开发板资料连载第六十三章 UCOSII 实验...
1)实验平台:alientek 阿波罗 STM32F767 开发板 2)摘自<STM32F7 开发指南(HAL 库版)>关注官方微信号公众号,获取更多资料:正点原子 http://weix ...
最新文章
- 用户组管理之更新分组表数据
- 「翻译」SAP MM 供应商评估流程初阶
- [ 墨者学院 ] 命令执行——Bash漏洞分析溯源
- 【转】快捷支付详解--比较详细
- 显示lib包_【手把手教你】股市技术分析利器之TA-Lib(一)
- openStreetMap学习网站
- OnItemClickListener,OnScrollListener应用
- zabbix mysql 平台_监控平台-zabbix
- Linux 学习笔记 二
- Atitit 提升记忆效率 有损压缩原理总结 目录 1. 常见方法	1 1.1. 抽象化提升一层 概念化	1 1.2. 骨架 ,目录化 大纲化 归纳整理	1 1.3. 提取关键词 ,摘要 ,
- MFC Windows程序设计源码免费下载
- VB2010(1)_Hello User
- Python3之excel操作--xlsxwriter模块
- Gradle初级使用教程
- 【产业互联网周报】阿里云栖大会、百度世界大会召开:阿里重推“云端一体”、百度AI全面升级...
- 支付宝扫码转账到银行卡/飞行模式
- java容器之Map
- 关于项目上线(新浪云)
- AARRR(海盗模型)|原理+Python可视化实现
- [CTF] 关于php代码审计的MD5类的练习
热门文章
- 胜利祝酒词(1994)
- 采集练习(十二) python 采集之 xbmc 酷狗电台插件
- 标题可降解塑料之现代医药材料应用
- matlab圆柱内导热分离变量法,一维热传导方程数值解法及matlab实现分离变量法和有限差分法.doc...
- [雷]单元测试报错--Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.22.2:test
- android ril.java_Android-RIL流程分析
- 无用小程序之——论如何利用python的pyautogui和特别喜欢发“嗯”*n的人实现部分自动化QQ聊天
- Swift3 隐藏手机号中间四位
- 倒金字塔java语言_java打印正金字塔,倒金字塔和“水影”金字塔(示例代码)
- 知名猎头告诉你员工离职,企业招聘时的猎头费用,谁来买单?