- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
CFSDN坚持开源创造价值,我们致力于搭建一个资源共享平台,让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章快速入门Java中的Lambda表达式由作者收集整理,如果你对这篇文章有兴趣,记得点赞哟.
Lambda简介 。
Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块).
Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包: java.util.function 包以及 java.util.stream 包。 流(stream)就如同迭代器(iterator),但附加了许多额外的功能。 总的来说,lambda表达式和 stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化.
Lambda表达式本质上是匿名方法,其底层还是通过invokedynamic指令来生成匿名类来实现。它提供了更为简单的语法和写作方式,允许你通过表达式来代替函数式接口。在一些人看来,Lambda就是可以让你的代码变得更简洁,完全可以不使用——这种看法当然没问题,但重要的是lambda为Java带来了闭包。得益于Lamdba对集合的支持,通过Lambda在多核处理器条件下对集合遍历时的性能提高极大,另外我们可以以数据流的方式处理集合——这是非常有吸引力的.
Lambda语法 。
Lambda的语法极为简单,类似如下结构
1
|
(parameters) -> expression
|
或者 。
1
|
(parameters) -> { statements; }
|
Lambda表达式由三部分组成:
1、paramaters:类似方法中的形参列表,这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号.
2、->:可理解为“被用于”的意思 。
3、方法体:可以是表达式也可以代码块,是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回,这里的代码块块等同于方法的方法体。如果是表达式,也可以返回一个值或者什么都不反回.
我们通过以下几个示例来做说明:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
//示例1:不需要接受参数,直接返回10
()->
10
//示例2:接受两个int类型的参数,并返回这两个参数相加的和
(
int
x,
int
y)->x+y;
//示例2:接受x,y两个参数,该参数的类型由JVM根据上下文推断出来,并返回两个参数的和
(x,y)->x+y;
//示例3:接受一个字符串,并将该字符串打印到控制到,不反回结果
(String name)->System.out.println(name);
//示例4:接受一个推断类型的参数name,并将该字符串打印到控制台
name->System.out.println(name);
//示例5:接受两个String类型参数,并分别输出,不反回
(String name,String sex)->{System.out.println(name);System.out.println(sex)}
//示例6:接受一个参数x,并返回该该参数的两倍
x->
2
*x
|
Lambda用在哪里 。
在[函数式接口][1]中我们知道Lambda表达式的目标类型是函数性接口——每一个Lambda都能通过一个特定的函数式接口与一个给定的类型进行匹配。因此一个Lambda表达式能被应用在与其目标类型匹配的任何地方,lambda表达式必须和函数式接口的抽象函数描述一样的参数类型,它的返回类型也必须和抽象函数的返回类型兼容,并且他能抛出的异常也仅限于在函数的描述范围中.
接下来,我们看一个自定义的函数式接口示例:
1
2
3
4
5
6
|
@FunctionalInterface
interface
Converter<F, T>{
T convert(F from);
}
|
首先用传统的方式来使用该接口:
1
2
3
4
5
6
7
8
9
|
Converter<String ,Integer> converter=
new
Converter<String, Integer>() {
@Override
public
Integer convert(String from) {
return
Integer.valueOf(from);
}
};
Integer result = converter.convert(
"200"
);
System.out.println(result);
|
很显然这没任何问题,那么接下里就是Lambda上场的时刻,用Lambda实现Converter接口:
1
2
3
|
Converter<String ,Integer> converter=(param) -> Integer.valueOf(param);
Integer result = converter.convert(
"101"
);
System.out.println(result);
|
通过上例,我想你已经对Lambda的使用有了个简单的认识,下面,我们在用一个常用的Runnable做演示:
在以前我们可能会写下这种代码:
1
2
3
4
5
6
|
new
Thread(
new
Runnable() {
@Override
public
void
run() {
System.out.println(
"hello lambda"
);
}
}).start();
|
在某些情况下,大量的匿名类会让代码显得杂乱无章。现在可以用Lambda来使它变得简洁:
1
|
new
Thread(() -> System.out.println(
"hello lambda"
)).start();
|
方法引用 。
方法引用是Lambda表达式的一个简化写法。所引用的方法其实是Lambda表达式的方法体的实现,其语法结构为
1
|
ObjectRef::methodName
|
左边可以是类名或者实例名,中间是方法引用符号”::”,右边是相应的方法名.
方法引用被分为三类:
1. 静态方法引用 。
在某些情况下,我们可能写出这样的代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public
class
ReferenceTest {
public
static
void
main(String[] args) {
Converter<String ,Integer> converter=
new
Converter<String, Integer>() {
@Override
public
Integer convert(String from) {
return
ReferenceTest.String2Int(from);
}
};
converter.convert(
"120"
);
}
@FunctionalInterface
interface
Converter<F,T>{
T convert(F from);
}
static
int
String2Int(String from) {
return
Integer.valueOf(from);
}
}
|
这时候如果用静态引用会使的代码更加简洁:
1
2
|
Converter<String, Integer> converter = ReferenceTest::String2Int;
converter.convert(
"120"
);
|
2. 实例方法引用 。
我们也可能会写下这样的代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public
class
ReferenceTest {
public
static
void
main(String[] args) {
Converter<String, Integer> converter =
new
Converter<String, Integer>() {
@Override
public
Integer convert(String from) {
return
new
Helper().String2Int(from);
}
};
converter.convert(
"120"
);
}
@FunctionalInterface
interface
Converter<F, T> {
T convert(F from);
}
static
class
Helper {
public
int
String2Int(String from) {
return
Integer.valueOf(from);
}
}
}
|
同样用实例方法引用会显得更加简洁:
1
2
3
|
Helper helper =
new
Helper();
Converter<String, Integer> converter = helper::String2Int;
converter.convert(
"120"
);
|
3. 构造方法引用 。
现在我们来演示构造方法的引用。首先我们定义一个父类Animal
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class
Animal{
private
String name;
private
int
age;
public
Animal(String name,
int
age) {
this
.name = name;
this
.age = age;
}
public
void
behavior(){
}
}
|
接下来,我们在定义两个Animal的子类:Dog、Bird 。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public
class
Bird
extends
Animal {
public
Bird(String name,
int
age) {
super
(name, age);
}
@Override
public
void
behavior() {
System.out.println(
"fly"
);
}
}
class
Dog
extends
Animal {
public
Dog(String name,
int
age) {
super
(name, age);
}
@Override
public
void
behavior() {
System.out.println(
"run"
);
}
}
|
随后我们定义工厂接口:
1
2
3
|
interface
Factory<T
extends
Animal> {
T create(String name,
int
age);
}
|
接下来我们还是用传统的方法来创建Dog类和Bird类的对象:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
Factory factory=
new
Factory() {
@Override
public
Animal create(String name,
int
age) {
return
new
Dog(name,age);
}
};
factory.create(
"alias"
,
3
);
factory=
new
Factory() {
@Override
public
Animal create(String name,
int
age) {
return
new
Bird(name,age);
}
};
factory.create(
"smook"
,
2
);
|
仅仅为了创建两个对象就写了十多号代码,现在我们用构造函数引用试试:
1
2
3
4
5
|
Factory<Animal> dogFactory =Dog::
new
;
Animal dog = dogFactory.create(
"alias"
,
4
);
Factory<Bird> birdFactory = Bird::
new
;
Bird bird = birdFactory.create(
"smook"
,
3
);
|
这样代码就显得干净利落了。通过Dog::new这种方式来穿件对象时,Factory.create函数的签名选择相应的造函数.
Lambda的域以及访问限制 。
域即作用域,Lambda表达式中的参数列表中的参数在该Lambda表达式范围内(域)有效。在作用Lambda表达式内,可以访问外部的变量:局部变量、类变量和静态变量,但操作受限程度不一.
访问局部变量 。
在Lambda表达式外部的局部变量会被JVM隐式的编译成final类型,因此只能访问外而不能修改.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
class
ReferenceTest {
public
static
void
main(String[] args) {
int
n =
3
;
Calculate calculate = param -> {
//n=10; 编译错误
return
n + param;
};
calculate.calculate(
10
);
}
@FunctionalInterface
interface
Calculate {
int
calculate(
int
value);
}
}
|
访问静态变量和成员变量 。
在Lambda表达式内部,对静态变量和成员变量可读可写.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public
class
ReferenceTest {
public
int
count =
1
;
public
static
int
num =
2
;
public
void
test() {
Calculate calculate = param -> {
num =
10
;
//修改静态变量
count =
3
;
//修改成员变量
return
n + param;
};
calculate.calculate(
10
);
}
public
static
void
main(String[] args) {
}
@FunctionalInterface
interface
Calculate {
int
calculate(
int
value);
}
}
|
Lambda不能访问函数接口的默认方法 。
java8增强了接口,其中包括接口可添加default关键词定义的默认方法,这里我们需要注意,Lambda表达式内部不支持访问默认方法.
Lambda实践 。
在[函数式接口][2]一节中,我们提到java.util.function包中内置许多函数式接口,现在将对常用的函数式接口做说明.
Predicate接口 。
输入一个参数,并返回一个Boolean值,其中内置许多用于逻辑判断的默认方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
@Test
public
void
predicateTest() {
Predicate<String> predicate = (s) -> s.length() >
0
;
boolean
test = predicate.test(
"test"
);
System.out.println(
"字符串长度大于0:"
+ test);
test = predicate.test(
""
);
System.out.println(
"字符串长度大于0:"
+ test);
test = predicate.negate().test(
""
);
System.out.println(
"字符串长度小于0:"
+ test);
Predicate<Object> pre = Objects::nonNull;
Object ob =
null
;
test = pre.test(ob);
System.out.println(
"对象不为空:"
+ test);
ob =
new
Object();
test = pre.test(ob);
System.out.println(
"对象不为空:"
+ test);
}
|
Function接口 。
接收一个参数,返回单一的结果,默认的方法(andThen)可将多个函数串在一起,形成复合Funtion(有输入,有输出)结果, 。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
@Test
public
void
functionTest() {
Function<String, Integer> toInteger = Integer::valueOf;
//toInteger的执行结果作为第二个backToString的输入
Function<String, String> backToString = toInteger.andThen(String::valueOf);
String result = backToString.apply(
"1234"
);
System.out.println(result);
Function<Integer, Integer> add = (i) -> {
System.out.println(
"frist input:"
+ i);
return
i *
2
;
};
Function<Integer, Integer> zero = add.andThen((i) -> {
System.out.println(
"second input:"
+ i);
return
i *
0
;
});
Integer res = zero.apply(
8
);
System.out.println(res);
}
|
Supplier接口 。
返回一个给定类型的结果,与Function不同的是,Supplier不需要接受参数(供应者,有输出无输入) 。
1
2
3
4
5
6
|
@Test
public
void
supplierTest() {
Supplier<String> supplier = () ->
"special type value"
;
String s = supplier.get();
System.out.println(s);
}
|
Consumer接口 。
代表了在单一的输入参数上需要进行的操作。和Function不同的是,Consumer没有返回值(消费者,有输入,无输出) 。
1
2
3
4
5
6
7
8
9
|
@Test
public
void
consumerTest() {
Consumer<Integer> add5 = (p) -> {
System.out.println(
"old value:"
+ p);
p = p +
5
;
System.out.println(
"new value:"
+ p);
};
add5.accept(
10
);
}
|
以上四个接口的用法代表了java.util.function包中四种类型,理解这四个函数式接口之后,其他的接口也就容易理解了,现在我们来做一下简单的总结:
Predicate用来逻辑判断,Function用在有输入有输出的地方,Supplier用在无输入,有输出的地方,而Consumer用在有输入,无输出的地方。你大可通过其名称的含义来获知其使用场景.
Stream 。
Lambda为java8带了闭包,这一特性在集合操作中尤为重要:java8中支持对集合对象的stream进行函数式操作,此外,stream api也被集成进了collection api,允许对集合对象进行批量操作.
下面我们来认识Stream.
Stream表示数据流,它没有数据结构,本身也不存储元素,其操作也不会改变源Stream,而是生成新Stream.作为一种操作数据的接口,它提供了过滤、排序、映射、规约等多种操作方法,这些方法按照返回类型被分为两类:凡是返回Stream类型的方法,称之为中间方法(中间操作),其余的都是完结方法(完结操作)。完结方法返回一个某种类型的值,而中间方法则返回新的Stream。中间方法的调用通常是链式的,该过程会形成一个管道,当完结方法被调用时会导致立即从管道中消费值,这里我们要记住:Stream的操作尽可能以“延迟”的方式运行,也就是我们常说的“懒操作”,这样有助于减少资源占用,提高性能。对于所有的中间操作(除sorted外)都是运行在延迟模式下.
Stream不但提供了强大的数据操作能力,更重要的是Stream既支持串行也支持并行,并行使得Stream在多核处理器上有着更好的性能.
Stream的使用过程有着固定的模式:
1、创建Stream 。
2、通过中间操作,对原始Stream进行“变化”并生成新的Stream 。
3、使用完结操作,生成最终结果 。
也就是 。
创建——>变化——>完结 。
Stream的创建 。
对于集合来说,可以通过调用集合的stream()或者parallelStream()来创建,另外这两个方法也在Collection接口中实现了。对于数组来说,可以通过Stream的静态方法of(T … values)来创建,另外,Arrays也提供了有关stream的支持.
除了以上基于集合或者数组来创建Stream,也可以通过Steam.empty()创建空的Stream,或者利用Stream的generate()来创建无穷的Stream.
下面我们以串行Stream为例,分别说明Stream几种常用的中间方法和完结方法。首先创建一个List集合:
1
2
3
4
5
6
7
|
List<String> lists=
new
ArrayList<String >();
lists.add(
"a1"
);
lists.add(
"a2"
);
lists.add(
"b1"
);
lists.add(
"b2"
);
lists.add(
"b3"
);
lists.add(
"o1"
);
|
中间方法 。
过滤器(Filter) 。
结合Predicate接口,Filter对流对象中的所有元素进行过滤,该操作是一个中间操作,这意味着你可以在操作返回结果的基础上进行其他操作.
1
2
3
4
5
6
7
8
9
10
11
|
public
static
void
streamFilterTest() {
lists.stream().filter((s -> s.startsWith(
"a"
))).forEach(System.out::println);
//等价于以上操作
Predicate<String> predicate = (s) -> s.startsWith(
"a"
);
lists.stream().filter(predicate).forEach(System.out::println);
//连续过滤
Predicate<String> predicate1 = (s -> s.endsWith(
"1"
));
lists.stream().filter(predicate).filter(predicate1).forEach(System.out::println);
}
|
排序(Sorted) 。
结合Comparator接口,该操作返回一个排序过后的流的视图,原始流的顺序不会改变。通过Comparator来指定排序规则,默认是按照自然顺序排序.
1
2
3
4
5
6
7
8
|
public
static
void
streamSortedTest() {
System.out.println(
"默认Comparator"
);
lists.stream().sorted().filter((s -> s.startsWith(
"a"
))).forEach(System.out::println);
System.out.println(
"自定义Comparator"
);
lists.stream().sorted((p1, p2) -> p2.compareTo(p1)).filter((s -> s.startsWith(
"a"
))).forEach(System.out::println);
}
|
映射(Map) 。
结合Function接口,该操作能将流对象中的每个元素映射为另一种元素,实现元素类型的转换.
1
2
3
4
5
6
7
8
9
10
|
public
static
void
streamMapTest() {
lists.stream().map(String::toUpperCase).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);
System.out.println(
"自定义映射规则"
);
Function<String, String> function = (p) -> {
return
p +
".txt"
;
};
lists.stream().map(String::toUpperCase).map(function).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);
}
|
在上面简单介绍了三种常用的操作,这三种操作极大简化了集合的处理。接下来,介绍几种完结方法:
完结方法 。
“变换”过程之后,需要获取结果,即完成操作。下面我们来看相关的操作:
匹配(Match) 。
用来判断某个predicate是否和流对象相匹配,最终返回Boolean类型结果,例如:
1
2
3
4
5
6
7
8
9
|
public
static
void
streamMatchTest() {
//流对象中只要有一个元素匹配就返回true
boolean
anyStartWithA = lists.stream().anyMatch((s -> s.startsWith(
"a"
)));
System.out.println(anyStartWithA);
//流对象中每个元素都匹配就返回true
boolean
allStartWithA
= lists.stream().allMatch((s -> s.startsWith(
"a"
)));
System.out.println(allStartWithA);
}
|
收集(Collect) 。
在对经过变换之后,我们将变换的Stream的元素收集,比如将这些元素存至集合中,此时便可以使用Stream提供的collect方法,例如:
1
2
3
4
5
|
public
static
void
streamCollectTest() {
List<String> list = lists.stream().filter((p) -> p.startsWith(
"a"
)).sorted().collect(Collectors.toList());
System.out.println(list);
}
|
计数(Count) 。
类似sql的count,用来统计流中元素的总数,例如:
1
2
3
4
|
public
static
void
streamCountTest() {
long
count = lists.stream().filter((s -> s.startsWith(
"a"
))).count();
System.out.println(count);
}
|
规约(Reduce) 。
reduce方法允许我们用自己的方式去计算元素或者将一个Stream中的元素以某种规律关联,例如:
1
2
3
4
5
6
|
public
static
void
streamReduceTest() {
Optional<String> optional = lists.stream().sorted().reduce((s1, s2) -> {
System.out.println(s1 +
"|"
+ s2);
return
s1 +
"|"
+ s2;
});
}
|
执行结果如下:
1
2
3
4
5
|
a1|a2
a1|a2|b1
a1|a2|b1|b2
a1|a2|b1|b2|b3
a1|a2|b1|b2|b3|o1
|
并行Stream VS 串行Stream 。
到目前我们已经将常用的中间操作和完结操作介绍完了。当然所有的的示例都是基于串行Stream。接下来介绍重点戏——并行Stream(parallel Stream)。并行Stream基于Fork-join并行分解框架实现,将大数据集合切分为多个小数据结合交给不同的线程去处理,这样在多核处理情况下,性能会得到很大的提高。这和MapReduce的设计理念一致:大任务化小,小任务再分配到不同的机器执行。只不过这里的小任务是交给不同的处理器.
通过parallelStream()创建并行Stream。为了验证并行Stream是否真的能提高性能,我们执行以下测试代码:
首先创建一个较大的集合:
1
2
3
4
5
|
List<String> bigLists =
new
ArrayList<>();
for
(
int
i =
0
; i <
10000000
; i++) {
UUID uuid = UUID.randomUUID();
bigLists.add(uuid.toString());
}
|
测试串行流下排序所用的时间:
1
2
3
4
5
6
7
8
|
private
static
void
notParallelStreamSortedTest(List<String> bigLists) {
long
startTime = System.nanoTime();
long
count = bigLists.stream().sorted().count();
long
endTime = System.nanoTime();
long
millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
System.out.println(System.out.printf(
"串行排序: %d ms"
, millis));
}
|
测试并行流下排序所用的时间:
1
2
3
4
5
6
7
8
|
private
static
void
parallelStreamSortedTest(List<String> bigLists) {
long
startTime = System.nanoTime();
long
count = bigLists.parallelStream().sorted().count();
long
endTime = System.nanoTime();
long
millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
System.out.println(System.out.printf(
"并行排序: %d ms"
, millis));
}
|
结果如下:
串行排序: 13336 ms 并行排序: 6755 ms 。
看到这里,我们确实发现性能提高了约么50%,你也可能会想以后都用parallel Stream不久行了么?实则不然,如果你现在还是单核处理器,而数据量又不算很大的情况下,串行流仍然是这种不错的选择。你也会发现在某些情况,串行流的性能反而更好,至于具体的使用,需要你根据实际场景先测试后再决定.
懒操作 。
上面我们谈到Stream尽可能以延迟的方式运行,这里通过创建一个无穷大的Stream来说明:
首先通过Stream的generate方法来一个自然数序列,然后通过map变换Stream:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
//递增序列
class
NatureSeq
implements
Supplier<Long> {
long
value =
0
;
@Override
public
Long get() {
value++;
return
value;
}
}
public
void
streamCreateTest() {
Stream<Long> stream = Stream.generate(
new
NatureSeq());
System.out.println(
"元素个数:"
+stream.map((param) -> {
return
param;
}).limit(
1000
).count());
}
|
执行结果为:
元素个数:1000 。
我们发现开始时对这个无穷大的Stream做任何中间操作(如:filter,map等,但sorted不行)都是可以的,也就是对Stream进行中间操作并生存一个新的Stream的过程并非立刻生效的(不然此例中的map操作会永远的运行下去,被阻塞住),当遇到完结方法时stream才开始计算。通过limit()方法,把这个无穷的Stream转为有穷的Stream.
总结 。
以上就是Java Lambda快速入门详解的全部内容,看完本文后大家是不是对Java Lambda有了更深的了解,希望本文对大家学习Java Lambda能有所帮助.
最后此篇关于快速入门Java中的Lambda表达式的文章就讲到这里了,如果你想了解更多关于快速入门Java中的Lambda表达式的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
Hive —— 入门 Hive介绍 Apache Hive是一款建立在Hadoop之上的开源数据仓库系统,可以将存储在Hadoop文件中的结构化、半结构化数据文件映射为一张数据库表,基于表提供了一
HBase —— 入门 HBase介绍 HBase是一个分布式的、面向列的开源数据库,该技术来源于 Fay Chang 所撰写的Google论文“Bigtable:一个结构化数据的分布式存储系统”
零:前端目前形势 前端的发展史 HTML(5)、CSS(3)、JavaScript(ES5、ES6):编写一个个的页面 -> 给后端(PHP、Python、Go、Java) ->
在本教程中,您将了解在计算机上运行 JavaScript 的不同方法。 JavaScript 是一种流行的编程语言,具有广泛的应用程序。 JavaScript 以前主要用于使网页具有交
我曾经是一个对编程一窍不通的小白,但因为对互联网世界的好奇心和求知欲的驱使,我踏入了编程的殿堂。在学习的过程中,我发现了一门神奇的编程语言——Python。Python有着简洁、易读的语法,让初学者能
嗨,亲爱的读者们! 今天我要给大家分享一些关于Python爬虫的小案例。你是否曾为了获取特定网页上的数据而烦恼过?或者是否好奇如何从网页中提取信息以供自己使用?那么,这篇文章将会给你一些启示和灵感。
关闭。这个问题是opinion-based 。目前不接受答案。 想要改进这个问题吗?更新问题,以便 editing this post 可以用事实和引文来回答它。 . 已关闭 8 年前。 Improv
我想创建一个像https://apprtc.appspot.com/?r=04188292这样的应用程序。我对 webrtc 了解一点,但无法掌握 google app-engine。如何为 java
我刚刚开始使用 Python 并编写了一个简单的周边程序。但是,每当我在终端中键入 python perimeter.py 时,都会收到以下错误,我不知道如何解决。 >>> python perime
Redis有5个基本数据结构,string、list、hash、set和zset。它们是日常开发中使用频率非常高应用最为广泛的数据结构,把这5个数据结构都吃透了,你就掌握了Redis应用知识的一半了
创建发布web项目 具体步骤: 1.在开发工具中创建一个dynamic web project helloword 2.在webContent中创建index.html文件 3.发布web应用到
如果你在 Ubuntu 上使用终端的时间很长,你可能会希望调整终端的字体和大小以获取一种良好的体验。 更改字体是一种最简单但最直观的 Linux 的终端自定义 的方法。让我
1. 前言 ADODB 是 Active Data Objects Data Base 的简称,它是一种 PHP 存取数据库的函式组件。现在 SFS3 系统 (校园自由软件交流网学务系统) 计划的
我对 neo4j 完全陌生,我很抱歉提出这样一个基本问题。我已经安装了neo4j,我正在使用shell“localhost:7474/webadmin/#/console/” 我正在寻找一个很好的例子
我正在阅读 ios 4 的核心音频,目的是构建一个小测试应用程序。 在这一点上,我对所有 api 的研究感到非常困惑。理想情况下,我想知道如何从两个 mp3 中提取一些样本到数组中。 然后在回调循环中
关闭。这个问题不符合Stack Overflow guidelines .它目前不接受答案。 要求我们推荐或查找工具、库或最喜欢的场外资源的问题对于 Stack Overflow 来说是无关紧要的,因
我下载了 GNUStep并安装了它,但是我不确定在哪里可以找到 IDE。有谁知道什么程序可以用作 GNUStep IDE/从哪里获取它们?否则,有没有人知道有关如何创建和编译基本 GNUStep 程序
我正在尝试开始使用 Apache Solr,但有些事情我不清楚。通读tutorial ,我已经设置了一个正在运行的 Solr 实例。我感到困惑的是 Solr 的所有配置(架构等)都是 XML 格式的。
请问有没有关于如何开始使用 BruTile 的文档? 我目前正在使用 SharpMap,我需要预缓存切片以加快进程 最佳答案 我今天正在研究这个:)Mapsui项目site严重依赖 SharpMap
尽我所能,我无法让 CEDET 做任何事情。 Emacs 24.3。我下载了最新的 CEDET 快照。我从他的底部(不是这样)Gentle Introduction 中获取了 Alex Ott 的设置
我是一名优秀的程序员,十分优秀!