- 浏览: 116982 次
- 性别:
- 来自: 北京
-
文章分类
最新评论
-
liubang201010:
可看看此文:http://www.goodu.info/gc/ ...
基于Android手机开发平台的移动数字图书馆服务系统研究 -
chenhaodejia:
hbxflihua 写道你好,在加载xml的时候能不能像htm ...
android自定义Spinner下拉菜单样式并获得选项的值 -
chenhaodejia:
心灵花园2010 写道你好,问下服务端该怎么去搭建?
什么意思 ...
基于Android手机开发平台的移动数字图书馆服务系统研究 -
心灵花园2010:
你好,问下服务端该怎么去搭建?
基于Android手机开发平台的移动数字图书馆服务系统研究 -
hbxflihua:
你好,在加载xml的时候能不能像html页面的select标签 ...
android自定义Spinner下拉菜单样式并获得选项的值
避免建立对象
世界上没有免费的对象。虽然GC为每个线程都建立了临时对象池,可以使创建对象的代价变得小一些,但是分配内存永远都比不分配内存的代价大。
如果你在用户界面循环中分配对象内存,就会引发周期性的垃圾回收,用户就会觉得界面像打嗝一样一顿一顿的。
所以,除非必要,应尽量避免尽力对象的实例。下面的例子将帮助你理解这条原则:
当你从用户输入的数据中截取一段字符串时,尽量使用substring函数取得原始数据的一个子串,而不是为子串另外建立一份拷贝。这样你就有一个新的String对象,它与原始数据共享一个char数组。
如果你有一个函数返回一个String对象,而你确切的知道这个字符串会被附加到一个StringBuffer,那么,请改变这个函数的参数和实现方式,直接把结果附加到StringBuffer中,而不要再建立一个短命的临时对象。
一个更极端的例子是,把多维数组分成多个一维数组。
int数组比Integer数组好,这也概括了一个基本事实,两个平行的int数组比(int,int)对象数组性能要好很多。同理,这试用于所有基本类型的组合。
如果你想用一种容器存储(Foo,Bar)元组,尝试使用两个单独的Foo[]数组和Bar[]数组,一定比(Foo,Bar)数组效率更高。(也有例外的情况,就是当你建立一个API,让别人调用它的时候。这时候你要注重对API借口的设计而牺牲一点儿速度。当然在API的内部,你仍要尽可能的提高代码的效率)
总体来说,就是避免创建短命的临时对象。减少对象的创建就能减少垃圾收集,进而减少对用户体验的影响。
使用本地方法
当你在处理字串的时候,不要吝惜使用String.indexOf(), String.lastIndexOf()等特殊实现的方法(specialty methods)。这些方法都是使用C/C++实现的,比起Java循环快10到100倍。
使用实类比接口好
假设你有一个HashMap对象,你可以将它声明为HashMap或者Map:
Map myMap1 = new HashMap();
HashMap myMap2 = new HashMap();
哪个更好呢?
按照传统的观点Map会更好些,因为这样你可以改变他的具体实现类,只要这个类继承自Map接口。传统的观点对于传统的程序是正确的,但是它并不适合嵌入式系统。调用一个接口的引用会比调用实体类的引用多花费一倍的时间。
如果HashMap完全适合你的程序,那么使用Map就没有什么价值。如果有些地方你不能确定,先避免使用Map,剩下的交给IDE提供的重构功能好了。(当然公共API是一个例外:一个好的API常常会牺牲一些性能)
用静态方法比虚方法好
如果你不需要访问一个对象的成员变量,那么请把方法声明成static。虚方法执行的更快,因为它可以被直接调用而不需要一个虚函数表。另外你也可以通过声明体现出这个函数的调用不会改变对象的状态。
不用getter和setter
在很多本地语言如C++中,都会使用getter(比如:i = getCount())来避免直接访问成员变量(i = mCount)。在C++中这是一个非常好的习惯,因为编译器能够内联访问,如果你需要约束或调试变量,你可以在任何时候添加代码。
在Android上,这就不是个好主意了。虚方法的开销比直接访问成员变量大得多。在通用的接口定义中,可以依照OO的方式定义getters和setters,但是在一般的类中,你应该直接访问变量。
将成员变量缓存到本地
访问成员变量比访问本地变量慢得多,下面一段代码:
Java代码
1 for (int i = 0; i < this.mCount; i++)
2 dumpItem(this.mItems[i]);
最好改成这样:
Java代码
3 int count = this.mCount;
4 Item[] items = this.mItems;
5 for (int i = 0; i < count; i++)
6 dumpItems(items[i]);
(使用"this"是为了表明这些是成员变量)
另一个相似的原则是:永远不要在for的第二个条件中调用任何方法。如下面方法所示,在每次循环的时候都会调用getCount()方法,这样做比你在一个int先把结果保存起来开销大很多。
Java代码
7 for (int i = 0; i < this.getCount(); i++)
8 dumpItems(this.getItem(i));
同样如果你要多次访问一个变量,也最好先为它建立一个本地变量,例如:
Java代码
9 protected void drawHorizontalScrollBar(Canvas canvas, int width, int height) {
10 if (isHorizontalScrollBarEnabled()) {
11 int size = mScrollBar.getSize(false);
12 if (size <= 0) {
13 size = mScrollBarSize;
14 }
15 mScrollBar.setBounds(0, height - size, width, height);
16 mScrollBar.setParams(computeHorizontalScrollRange(),computeHorizontalScrollOffset(),computeHorizontalScrollExtent(), false);
17 mScrollBar.draw(canvas);
18 }
19 }
这里有4次访问成员变量mScrollBar,如果将它缓存到本地,4次成员变量访问就会变成4次效率更高的栈变量访问。
另外就是方法的参数与本地变量的效率相同。
使用常量
让我们来看看这两段在类前面的声明:
Java代码
20 static int intVal = 42;
21 static String strVal = "Hello, world!";
必以其会生成一个叫做<clinit>的初始化类的方法,当类第一次被使用的时候这个方法会被执行。方法会将42赋给intVal,然后把一个指向类中常量表的引用赋给strVal。当以后要用到这些值的时候,会在成员变量表中查找到他们。
下面我们做些改进,使用“final"关键字:
Java代码
22 static final int intVal = 42;
23 static final String strVal = "Hello, world!";
现在,类不再需要<clinit>方法,因为在成员变量初始化的时候,会将常量直接保存到类文件中。用到intVal的代码被直接替换成42,而使用strVal的会指向一个字符串常量,而不是使用成员变量。
将一个方法或类声明为"final"不会带来性能的提升,但是会帮助编译器优化代码。举例说,如果编译器知道一个"getter"方法不会被重载,那么编译器会对其采用内联调用。
你也可以将本地变量声明为"final",同样,这也不会带来性能的提升。使用"final"只能使本地变量看起来更清晰些(但是也有些时候这是必须的,比如在使用匿名内部类的时候)(xing:原文是 or you have to, e.g. for use in an anonymous inner class)
谨慎使用foreach
foreach可以用在实现了Iterable接口的集合类型上。foreach会给这些对象分配一个iterator,然后调用 hasNext()和next()方法。你最好使用foreach处理ArrayList对象,但是对其他集合对象,foreach相当于使用 iterator。
下面展示了foreach一种可接受的用法:
Java代码
24 public class Foo {
25 int mSplat;
26 static Foo mArray[] = new Foo[27];
27
28 public static void zero() {
29 int sum = 0;
30 for (int i = 0; i < mArray.length; i++) {
31 sum += mArray[i].mSplat;
32 }
33 }
34
35 public static void one() {
36 int sum = 0;
37 Foo[] localArray = mArray;
38 int len = localArray.length;
39 for (int i = 0; i < len; i++) {
40 sum += localArray[i].mSplat;
41 }
42 }
43
44 public static void two() {
45 int sum = 0;
46 for (Foo a: mArray) {
47 sum += a.mSplat;
48 }
49 }
50 }
在zero()中,每次循环都会访问两次静态成员变量,取得一次数组的长度。
retrieves the static field twice and gets the array length once for every iteration through the loop.
在one()中,将所有成员变量存储到本地变量。
pulls everything out into local variables, avoiding the lookups.
two()使用了在java1.5中引入的foreach语法。编译器会将对数组的引用和数组的长度保存到本地变量中,这对访问数组元素非常好。但是编译器还会在每次循环中产生一个额外的对本地变量的存储操作(对变量a的存取)这样会比one()多出4个字节,速度要稍微慢一些。
综上所述:foreach语法在运用于array时性能很好,但是运用于其他集合对象时要小心,因为它会产生额外的对象。
避免使用枚举
枚举变量非常方便,但不幸的是它会牺牲执行的速度和并大幅增加文件体积。例如:
public class Foo {public enum Shrubbery { GROUND, CRAWLING, HANGING }}
会产生一个900字节的.class文件(Foo$Shubbery.class)。在它被首次调用时,这个类会调用初始化方法来准备每个枚举变量。每个枚举项都会被声明成一个静态变量,并被赋值。然后将这些静态变量放在一个名为"$VALUES"的静态数组变量中。而这么一大堆代码,仅仅是为了使用三个整数。
这样:
Shrubbery shrub = Shrubbery.GROUND;会引起一个对静态变量的引用,如果这个静态变量是final int,那么编译器会直接内联这个常数。
一方面说,使用枚举变量可以让你的API更出色,并能提供编译时的检查。所以在通常的时候你毫无疑问应该为公共API选择枚举变量。但是当性能方面有所限制的时候,你就应该避免这种做法了。
有些情况下,使用ordinal()方法获取枚举变量的整数值会更好一些,举例来说,将:
Java代码
51 for (int n = 0; n < list.size(); n++) {
52 if (list.items[n].e == MyEnum.VAL_X)// do stuff 1
53 else if (list.items[n].e == MyEnum.VAL_Y)// do stuff 2
54 }
替换为:
Java代码
55 int valX = MyEnum.VAL_X.ordinal();
56 int valY = MyEnum.VAL_Y.ordinal();
57 int count = list.size();
58 MyItem items = list.items();
59 for (int n = 0; n < count; n++) {
60 int valItem = items[n].e.ordinal();
61 if (valItem == valX)// do stuff 1
62 else if (valItem == valY)// do stuff 2
63 }
会使性能得到一些改善,但这并不是最终的解决之道。
将与内部类一同使用的变量声明在包范围内
请看下面的类定义:
Java代码
64 public class Foo {
65 private int mValue;
66 public void run() {
67 Inner in = new Inner();
68 mValue = 27;
69 in.stuff();
70 }
71
72 private void doStuff(int value) {
73 System.out.println("Value is " + value);
74 }
75
76 private class Inner {
77 void stuff() {
78 Foo.this.doStuff(Foo.this.mValue);
79 }
80 }
81 }
这其中的关键是,我们定义了一个内部类(Foo$Inner),它需要访问外部类的私有域变量和函数。这是合法的,并且会打印出我们希望的结果"Value is 27"。
问题是在技术上来讲(在幕后)Foo$Inner是一个完全独立的类,它要直接访问Foo的私有成员是非法的。要跨越这个鸿沟,编译器需要生成一组方法:
Java代码
82 static int Foo.access$100(Foo foo) {
83 return foo.mValue;
84 }
85
86 static void Foo.access$200(Foo foo, int value) {
87 foo.doStuff(value);
88 }
内部类在每次访问"mValue"和"doStuff"方法时,都会调用这些静态方法。就是说,上面的代码说明了一个问题,你是在通过接口方法访问这些成员变量和函数而不是直接调用它们。在前面我们已经说过,使用接口方法(getter、setter)比直接访问速度要慢。所以这个例子就是在特定语法下面产生的一个“隐性的”性能障碍。
通过将内部类访问的变量和函数声明由私有范围改为包范围,我们可以避免这个问题。这样做可以让代码运行更快,并且避免产生额外的静态方法。(遗憾的是,这些域和方法可以被同一个包内的其他类直接访问,这与经典的OO原则相违背。因此当你设计公共API的时候应该谨慎使用这条优化原则)
避免使用浮点数
在奔腾CPU出现之前,游戏设计者做得最多的就是整数运算。随着奔腾的到来,浮点运算处理器成为了CPU内置的特性,浮点和整数配合使用,能够让你的游戏运行得更顺畅。通常在桌面电脑上,你可以随意的使用浮点运算。
但是非常遗憾,嵌入式处理器通常没有支持浮点运算的硬件,所有对"float"和"double"的运算都是通过软件实现的。一些基本的浮点运算,甚至需要毫秒级的时间才能完成。
甚至是整数,一些芯片有对乘法的硬件支持而缺少对除法的支持。这种情况下,整数的除法和取模运算也是有软件来完成的。所以当你在使用哈希表或者做大量数学运算时一定要小心谨慎。 ”
世界上没有免费的对象。虽然GC为每个线程都建立了临时对象池,可以使创建对象的代价变得小一些,但是分配内存永远都比不分配内存的代价大。
如果你在用户界面循环中分配对象内存,就会引发周期性的垃圾回收,用户就会觉得界面像打嗝一样一顿一顿的。
所以,除非必要,应尽量避免尽力对象的实例。下面的例子将帮助你理解这条原则:
当你从用户输入的数据中截取一段字符串时,尽量使用substring函数取得原始数据的一个子串,而不是为子串另外建立一份拷贝。这样你就有一个新的String对象,它与原始数据共享一个char数组。
如果你有一个函数返回一个String对象,而你确切的知道这个字符串会被附加到一个StringBuffer,那么,请改变这个函数的参数和实现方式,直接把结果附加到StringBuffer中,而不要再建立一个短命的临时对象。
一个更极端的例子是,把多维数组分成多个一维数组。
int数组比Integer数组好,这也概括了一个基本事实,两个平行的int数组比(int,int)对象数组性能要好很多。同理,这试用于所有基本类型的组合。
如果你想用一种容器存储(Foo,Bar)元组,尝试使用两个单独的Foo[]数组和Bar[]数组,一定比(Foo,Bar)数组效率更高。(也有例外的情况,就是当你建立一个API,让别人调用它的时候。这时候你要注重对API借口的设计而牺牲一点儿速度。当然在API的内部,你仍要尽可能的提高代码的效率)
总体来说,就是避免创建短命的临时对象。减少对象的创建就能减少垃圾收集,进而减少对用户体验的影响。
使用本地方法
当你在处理字串的时候,不要吝惜使用String.indexOf(), String.lastIndexOf()等特殊实现的方法(specialty methods)。这些方法都是使用C/C++实现的,比起Java循环快10到100倍。
使用实类比接口好
假设你有一个HashMap对象,你可以将它声明为HashMap或者Map:
Map myMap1 = new HashMap();
HashMap myMap2 = new HashMap();
哪个更好呢?
按照传统的观点Map会更好些,因为这样你可以改变他的具体实现类,只要这个类继承自Map接口。传统的观点对于传统的程序是正确的,但是它并不适合嵌入式系统。调用一个接口的引用会比调用实体类的引用多花费一倍的时间。
如果HashMap完全适合你的程序,那么使用Map就没有什么价值。如果有些地方你不能确定,先避免使用Map,剩下的交给IDE提供的重构功能好了。(当然公共API是一个例外:一个好的API常常会牺牲一些性能)
用静态方法比虚方法好
如果你不需要访问一个对象的成员变量,那么请把方法声明成static。虚方法执行的更快,因为它可以被直接调用而不需要一个虚函数表。另外你也可以通过声明体现出这个函数的调用不会改变对象的状态。
不用getter和setter
在很多本地语言如C++中,都会使用getter(比如:i = getCount())来避免直接访问成员变量(i = mCount)。在C++中这是一个非常好的习惯,因为编译器能够内联访问,如果你需要约束或调试变量,你可以在任何时候添加代码。
在Android上,这就不是个好主意了。虚方法的开销比直接访问成员变量大得多。在通用的接口定义中,可以依照OO的方式定义getters和setters,但是在一般的类中,你应该直接访问变量。
将成员变量缓存到本地
访问成员变量比访问本地变量慢得多,下面一段代码:
Java代码
1 for (int i = 0; i < this.mCount; i++)
2 dumpItem(this.mItems[i]);
最好改成这样:
Java代码
3 int count = this.mCount;
4 Item[] items = this.mItems;
5 for (int i = 0; i < count; i++)
6 dumpItems(items[i]);
(使用"this"是为了表明这些是成员变量)
另一个相似的原则是:永远不要在for的第二个条件中调用任何方法。如下面方法所示,在每次循环的时候都会调用getCount()方法,这样做比你在一个int先把结果保存起来开销大很多。
Java代码
7 for (int i = 0; i < this.getCount(); i++)
8 dumpItems(this.getItem(i));
同样如果你要多次访问一个变量,也最好先为它建立一个本地变量,例如:
Java代码
9 protected void drawHorizontalScrollBar(Canvas canvas, int width, int height) {
10 if (isHorizontalScrollBarEnabled()) {
11 int size = mScrollBar.getSize(false);
12 if (size <= 0) {
13 size = mScrollBarSize;
14 }
15 mScrollBar.setBounds(0, height - size, width, height);
16 mScrollBar.setParams(computeHorizontalScrollRange(),computeHorizontalScrollOffset(),computeHorizontalScrollExtent(), false);
17 mScrollBar.draw(canvas);
18 }
19 }
这里有4次访问成员变量mScrollBar,如果将它缓存到本地,4次成员变量访问就会变成4次效率更高的栈变量访问。
另外就是方法的参数与本地变量的效率相同。
使用常量
让我们来看看这两段在类前面的声明:
Java代码
20 static int intVal = 42;
21 static String strVal = "Hello, world!";
必以其会生成一个叫做<clinit>的初始化类的方法,当类第一次被使用的时候这个方法会被执行。方法会将42赋给intVal,然后把一个指向类中常量表的引用赋给strVal。当以后要用到这些值的时候,会在成员变量表中查找到他们。
下面我们做些改进,使用“final"关键字:
Java代码
22 static final int intVal = 42;
23 static final String strVal = "Hello, world!";
现在,类不再需要<clinit>方法,因为在成员变量初始化的时候,会将常量直接保存到类文件中。用到intVal的代码被直接替换成42,而使用strVal的会指向一个字符串常量,而不是使用成员变量。
将一个方法或类声明为"final"不会带来性能的提升,但是会帮助编译器优化代码。举例说,如果编译器知道一个"getter"方法不会被重载,那么编译器会对其采用内联调用。
你也可以将本地变量声明为"final",同样,这也不会带来性能的提升。使用"final"只能使本地变量看起来更清晰些(但是也有些时候这是必须的,比如在使用匿名内部类的时候)(xing:原文是 or you have to, e.g. for use in an anonymous inner class)
谨慎使用foreach
foreach可以用在实现了Iterable接口的集合类型上。foreach会给这些对象分配一个iterator,然后调用 hasNext()和next()方法。你最好使用foreach处理ArrayList对象,但是对其他集合对象,foreach相当于使用 iterator。
下面展示了foreach一种可接受的用法:
Java代码
24 public class Foo {
25 int mSplat;
26 static Foo mArray[] = new Foo[27];
27
28 public static void zero() {
29 int sum = 0;
30 for (int i = 0; i < mArray.length; i++) {
31 sum += mArray[i].mSplat;
32 }
33 }
34
35 public static void one() {
36 int sum = 0;
37 Foo[] localArray = mArray;
38 int len = localArray.length;
39 for (int i = 0; i < len; i++) {
40 sum += localArray[i].mSplat;
41 }
42 }
43
44 public static void two() {
45 int sum = 0;
46 for (Foo a: mArray) {
47 sum += a.mSplat;
48 }
49 }
50 }
在zero()中,每次循环都会访问两次静态成员变量,取得一次数组的长度。
retrieves the static field twice and gets the array length once for every iteration through the loop.
在one()中,将所有成员变量存储到本地变量。
pulls everything out into local variables, avoiding the lookups.
two()使用了在java1.5中引入的foreach语法。编译器会将对数组的引用和数组的长度保存到本地变量中,这对访问数组元素非常好。但是编译器还会在每次循环中产生一个额外的对本地变量的存储操作(对变量a的存取)这样会比one()多出4个字节,速度要稍微慢一些。
综上所述:foreach语法在运用于array时性能很好,但是运用于其他集合对象时要小心,因为它会产生额外的对象。
避免使用枚举
枚举变量非常方便,但不幸的是它会牺牲执行的速度和并大幅增加文件体积。例如:
public class Foo {public enum Shrubbery { GROUND, CRAWLING, HANGING }}
会产生一个900字节的.class文件(Foo$Shubbery.class)。在它被首次调用时,这个类会调用初始化方法来准备每个枚举变量。每个枚举项都会被声明成一个静态变量,并被赋值。然后将这些静态变量放在一个名为"$VALUES"的静态数组变量中。而这么一大堆代码,仅仅是为了使用三个整数。
这样:
Shrubbery shrub = Shrubbery.GROUND;会引起一个对静态变量的引用,如果这个静态变量是final int,那么编译器会直接内联这个常数。
一方面说,使用枚举变量可以让你的API更出色,并能提供编译时的检查。所以在通常的时候你毫无疑问应该为公共API选择枚举变量。但是当性能方面有所限制的时候,你就应该避免这种做法了。
有些情况下,使用ordinal()方法获取枚举变量的整数值会更好一些,举例来说,将:
Java代码
51 for (int n = 0; n < list.size(); n++) {
52 if (list.items[n].e == MyEnum.VAL_X)// do stuff 1
53 else if (list.items[n].e == MyEnum.VAL_Y)// do stuff 2
54 }
替换为:
Java代码
55 int valX = MyEnum.VAL_X.ordinal();
56 int valY = MyEnum.VAL_Y.ordinal();
57 int count = list.size();
58 MyItem items = list.items();
59 for (int n = 0; n < count; n++) {
60 int valItem = items[n].e.ordinal();
61 if (valItem == valX)// do stuff 1
62 else if (valItem == valY)// do stuff 2
63 }
会使性能得到一些改善,但这并不是最终的解决之道。
将与内部类一同使用的变量声明在包范围内
请看下面的类定义:
Java代码
64 public class Foo {
65 private int mValue;
66 public void run() {
67 Inner in = new Inner();
68 mValue = 27;
69 in.stuff();
70 }
71
72 private void doStuff(int value) {
73 System.out.println("Value is " + value);
74 }
75
76 private class Inner {
77 void stuff() {
78 Foo.this.doStuff(Foo.this.mValue);
79 }
80 }
81 }
这其中的关键是,我们定义了一个内部类(Foo$Inner),它需要访问外部类的私有域变量和函数。这是合法的,并且会打印出我们希望的结果"Value is 27"。
问题是在技术上来讲(在幕后)Foo$Inner是一个完全独立的类,它要直接访问Foo的私有成员是非法的。要跨越这个鸿沟,编译器需要生成一组方法:
Java代码
82 static int Foo.access$100(Foo foo) {
83 return foo.mValue;
84 }
85
86 static void Foo.access$200(Foo foo, int value) {
87 foo.doStuff(value);
88 }
内部类在每次访问"mValue"和"doStuff"方法时,都会调用这些静态方法。就是说,上面的代码说明了一个问题,你是在通过接口方法访问这些成员变量和函数而不是直接调用它们。在前面我们已经说过,使用接口方法(getter、setter)比直接访问速度要慢。所以这个例子就是在特定语法下面产生的一个“隐性的”性能障碍。
通过将内部类访问的变量和函数声明由私有范围改为包范围,我们可以避免这个问题。这样做可以让代码运行更快,并且避免产生额外的静态方法。(遗憾的是,这些域和方法可以被同一个包内的其他类直接访问,这与经典的OO原则相违背。因此当你设计公共API的时候应该谨慎使用这条优化原则)
避免使用浮点数
在奔腾CPU出现之前,游戏设计者做得最多的就是整数运算。随着奔腾的到来,浮点运算处理器成为了CPU内置的特性,浮点和整数配合使用,能够让你的游戏运行得更顺畅。通常在桌面电脑上,你可以随意的使用浮点运算。
但是非常遗憾,嵌入式处理器通常没有支持浮点运算的硬件,所有对"float"和"double"的运算都是通过软件实现的。一些基本的浮点运算,甚至需要毫秒级的时间才能完成。
甚至是整数,一些芯片有对乘法的硬件支持而缺少对除法的支持。这种情况下,整数的除法和取模运算也是有软件来完成的。所以当你在使用哈希表或者做大量数学运算时一定要小心谨慎。 ”
发表评论
-
我今天打算推荐一下近期自己制作的一款app-吃惑
2016-07-13 17:12 492你是否有这样的习惯 ... -
android listview优化几种写法详细介绍
2015-02-18 14:58 769这篇文章只是总结下getView里面优化视图的几种写法,就像 ... -
利用convertView优化ListView性能
2015-02-18 14:26 711这里提到的ListView只是作为一个典型代表 其实在A ... -
Android之ListView原理学习与优化总结
2015-02-05 15:50 738在整理前几篇文章的时候有朋友提出写一下ListView的性 ... -
sleep()和wait()有什么区别
2015-02-04 09:38 797sleep就是正在执行的线程主动让出cpu,cp ... -
线程与进程的区别
2015-01-27 20:12 705线程是指进程内的一个执行单元,也是进程内的可调度实体.与进程 ... -
线程同步的几种方式(转)
2015-01-27 19:58 883进程中线程同步的四种常用方式: 1、 临界区(CCrit ... -
Eclipse提示No java virtual machine
2014-12-15 16:22 1074当你启动eclipse时出现... No java v ... -
解决客户端向服务器端传输中文乱码问题
2014-10-24 09:59 998客户端加码 Java code? ... -
重要通告
2012-02-05 11:36 921博客涉及到的所有源码,包括网站源码、Android源码等均在千 ... -
关于Android发送邮件
2011-09-11 08:40 3391Google 在发表 Android 手机平台时,强调的是超强 ... -
ImageButton点击背景切换事件
2011-08-23 14:30 2514问题:imagebutton初始显示图片1,当单击该image ... -
Android中ImageButton的运用详解
2011-08-23 14:13 2337ImageButton在Android的运用非常灵活,既可以在 ... -
Android拍照、录像、录音代码范例
2011-08-19 09:17 1303package com.cons.dcg.collect; i ... -
Android的Menu状态动态设置方法onPrepareOptionsMenu(Menu menu)
2011-08-12 11:49 2068覆盖onPrepareOptionsMenu(Menu men ... -
ArrayAdapter和BaseAdapter的区别是什么
2011-08-11 18:10 2169近期很多Android开发者来函表示对ArrayAdapt ... -
ArrayAdapter和List的关系
2011-08-11 18:00 21771、使用ArrayAdapter(数组适配器)顾名思义,需要把 ... -
Manifest权限大全
2011-08-09 17:38 1089<uses-permission android:nam ... -
Android中创建自己的ContentProvider
2011-08-09 17:37 1390Android是如何实现应用程序之间数据共享的?我们以 ... -
深入理解Android消息处理系统——Looper、Handler、Thread
2011-08-09 11:09 755熟悉Windows编程的朋友可能知道Windows程序是消息驱 ...
相关推荐
内容概要:本文详细介绍了基于MATLAB GUI界面和卷积神经网络(CNN)的模糊车牌识别系统。该系统旨在解决现实中车牌因模糊不清导致识别困难的问题。文中阐述了整个流程的关键步骤,包括图像的模糊还原、灰度化、阈值化、边缘检测、孔洞填充、形态学操作、滤波操作、车牌定位、字符分割以及最终的字符识别。通过使用维纳滤波或最小二乘法约束滤波进行模糊还原,再利用CNN的强大特征提取能力完成字符分类。此外,还特别强调了MATLAB GUI界面的设计,使得用户能直观便捷地操作整个系统。 适合人群:对图像处理和深度学习感兴趣的科研人员、高校学生及从事相关领域的工程师。 使用场景及目标:适用于交通管理、智能停车场等领域,用于提升车牌识别的准确性和效率,特别是在面对模糊车牌时的表现。 其他说明:文中提供了部分关键代码片段作为参考,并对实验结果进行了详细的分析,展示了系统在不同环境下的表现情况及其潜在的应用前景。
嵌入式八股文面试题库资料知识宝典-计算机专业试题.zip
嵌入式八股文面试题库资料知识宝典-C and C++ normal interview_3.zip
内容概要:本文深入探讨了一款额定功率为4kW的开关磁阻电机,详细介绍了其性能参数如额定功率、转速、效率、输出转矩和脉动率等。同时,文章还展示了利用RMxprt、Maxwell 2D和3D模型对该电机进行仿真的方法和技术,通过外电路分析进一步研究其电气性能和动态响应特性。最后,文章提供了基于RMxprt模型的MATLAB仿真代码示例,帮助读者理解电机的工作原理及其性能特点。 适合人群:从事电机设计、工业自动化领域的工程师和技术人员,尤其是对开关磁阻电机感兴趣的科研工作者。 使用场景及目标:适用于希望深入了解开关磁阻电机特性和建模技术的研究人员,在新产品开发或现有产品改进时作为参考资料。 其他说明:文中提供的代码示例仅用于演示目的,实际操作时需根据所用软件的具体情况进行适当修改。
少儿编程scratch项目源代码文件案例素材-剑客冲刺.zip
少儿编程scratch项目源代码文件案例素材-几何冲刺 转瞬即逝.zip
内容概要:本文详细介绍了基于PID控制器的四象限直流电机速度驱动控制系统仿真模型及其永磁直流电机(PMDC)转速控制模型。首先阐述了PID控制器的工作原理,即通过对系统误差的比例、积分和微分运算来调整电机的驱动信号,从而实现转速的精确控制。接着讨论了如何利用PID控制器使有刷PMDC电机在四个象限中精确跟踪参考速度,并展示了仿真模型在应对快速负载扰动时的有效性和稳定性。最后,提供了Simulink仿真模型和详细的Word模型说明文档,帮助读者理解和调整PID控制器参数,以达到最佳控制效果。 适合人群:从事电力电子与电机控制领域的研究人员和技术人员,尤其是对四象限直流电机速度驱动控制系统感兴趣的读者。 使用场景及目标:适用于需要深入了解和掌握四象限直流电机速度驱动控制系统设计与实现的研究人员和技术人员。目标是在实际项目中能够运用PID控制器实现电机转速的精确控制,并提高系统的稳定性和抗干扰能力。 其他说明:文中引用了多篇相关领域的权威文献,确保了理论依据的可靠性和实用性。此外,提供的Simulink模型和Word文档有助于读者更好地理解和实践所介绍的内容。
嵌入式八股文面试题库资料知识宝典-2013年海康威视校园招聘嵌入式开发笔试题.zip
少儿编程scratch项目源代码文件案例素材-驾驶通关.zip
小区开放对周边道路通行能力影响的研究.pdf
内容概要:本文探讨了冷链物流车辆路径优化问题,特别是如何通过NSGA-2遗传算法和软硬时间窗策略来实现高效、环保和高客户满意度的路径规划。文中介绍了冷链物流的特点及其重要性,提出了软时间窗概念,允许一定的配送时间弹性,同时考虑碳排放成本,以达到绿色物流的目的。此外,还讨论了如何将客户满意度作为路径优化的重要评价标准之一。最后,通过一段简化的Python代码展示了遗传算法的应用。 适合人群:从事物流管理、冷链物流运营的专业人士,以及对遗传算法和路径优化感兴趣的科研人员和技术开发者。 使用场景及目标:适用于冷链物流企业,旨在优化配送路线,降低运营成本,减少碳排放,提升客户满意度。目标是帮助企业实现绿色、高效的物流配送系统。 其他说明:文中提供的代码仅为示意,实际应用需根据具体情况调整参数设置和模型构建。
少儿编程scratch项目源代码文件案例素材-恐怖矿井.zip
内容概要:本文详细介绍了基于STM32F030的无刷电机控制方案,重点在于高压FOC(磁场定向控制)技术和滑膜无感FOC的应用。该方案实现了过载、过欠压、堵转等多种保护机制,并提供了完整的源码、原理图和PCB设计。文中展示了关键代码片段,如滑膜观测器和电流环处理,以及保护机制的具体实现方法。此外,还提到了方案的移植要点和实际测试效果,确保系统的稳定性和高效性。 适合人群:嵌入式系统开发者、电机控制系统工程师、硬件工程师。 使用场景及目标:适用于需要高性能无刷电机控制的应用场景,如工业自动化设备、无人机、电动工具等。目标是提供一种成熟的、经过验证的无刷电机控制方案,帮助开发者快速实现并优化电机控制性能。 其他说明:提供的资料包括详细的原理图、PCB设计文件、源码及测试视频,方便开发者进行学习和应用。
基于有限体积法Godunov格式的管道泄漏检测模型研究.pdf
嵌入式八股文面试题库资料知识宝典-CC++笔试题-深圳有为(2019.2.28)1.zip
少儿编程scratch项目源代码文件案例素材-几何冲刺 V1.5.zip
Android系统开发_Linux内核配置_USB-HID设备模拟_通过root权限将Android设备转换为全功能USB键盘的项目实现_该项目需要内核支持configFS文件系统
C# WPF - LiveCharts Project
少儿编程scratch项目源代码文件案例素材-恐怖叉子 动画.zip
嵌入式八股文面试题库资料知识宝典-嵌⼊式⼯程师⾯试⾼频问题.zip