1.collect算子

*使用foreachACTION操作 ,collect在远程集群中遍历RDD的元素

*使用collect操作,将分布式在远程集群中的数据拉取到本地
*这种方式不建议使用,如果数据量大,会使用大量 的网络带宽
*这种方式不建议使用。

package kw.test.action;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction; public class Collect {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("FlatMap").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<String> list = Arrays.asList("wo am xues","ni shi la ji ","zha zs","zha df");
JavaRDD<String> javaRDD = javaSparkContext.parallelize(list);
JavaRDD<String> result = javaRDD.flatMap(new FlatMapFunction<String, String>() { @Override
public Iterator<String> call(String arg0) throws Exception {
// TODO Auto-generated method stub
//首选将数据分割,然后将和数据值机型压扁。
return Arrays.asList(arg0.split(" ")).iterator();
}
});
List<String> str = result.collect();
for(String s : str)
{
System.out.println(s);
} }
}

 2.count

* 这个是一个action,他是有返回值的。

package kw.test.action;

import java.util.Arrays;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext; /*
* 这个是一个action,他是有返回值的。
*/
public class count {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("FlatMap").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<Integer> list = Arrays.asList(,,,,,,,,);
JavaRDD<Integer> javaRDD = javaSparkContext.parallelize(list);
long num = javaRDD.count();
System.out.println(num);
} }

3.filter

*将返回true的数据进行输出

package kw.test.action;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.VoidFunction; public class Filter {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("Filter").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<Integer> list = Arrays.asList(,,,,,);
JavaRDD<Integer> javaRDD = javaSparkContext.parallelize(list);
JavaRDD<Integer> redult = javaRDD.filter(new Function<Integer, Boolean>() { @Override
public Boolean call(Integer arg0) throws Exception {
// TODO Auto-generated method stub
return arg0%==;//返回的为true的就可以了。
}
});
redult.foreach(new VoidFunction<Integer>() { @Override
public void call(Integer arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg0);
}
});
}
}

4.coalesce

package kw.test.action;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.VoidFunction;
/*
* 此参数将返回一个RDD,分区的参数会别为设置的哪一个参数的个数
*
* 这个返回是一个窄依赖,如果将一个100的变为10个partition的时候,这个时候
* 不会进行shuffle运算,
*
* 如果将好多个partition变为一个的时候,这个时候需要使用shuffle,他会进行shuffle的传递
* 一般是较少使用,因为需要将数据进行传递。
*
*
*
* 不仅仅是将partition变得更少,同时也可以将partition变的更大,这个时候需要将shuffle变为true
* 如果将partition变的更多的时候,也是需要将将shuffle设置为true的。
*/ public class FilterOperter {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("Coalesce").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<Integer> list = Arrays.asList(1,2,3,4,5,6);
JavaRDD<Integer> numbers = javaSparkContext.parallelize(list,6);
//Colesce算子,在执行filter之后,有的partition上的数据就会变得很少,容易造成数据的倾斜
JavaRDD<String> result = numbers.mapPartitionsWithIndex(new Function2<Integer, Iterator<Integer>, Iterator<String>>() { @Override
public Iterator<String> call(Integer arg0, Iterator<Integer> arg1)
throws Exception {
// TODO Auto-generated method stub
List<String> list = new ArrayList<String>();
while(arg1.hasNext())
{
list.add(arg0+" "+arg1.next());
}
return list.iterator();
}
}, true); result.foreach(new VoidFunction<String>() { @Override
public void call(String arg1) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg1+" ");
} });
JavaRDD<String> javaCoaxlesce = result.coalesce(3);
JavaRDD<String> coalesce = javaCoaxlesce.mapPartitionsWithIndex(new Function2<Integer, Iterator<String>, Iterator<String>>() { @Override
public Iterator<String> call(Integer arg0, Iterator<String> arg1)
throws Exception {
// TODO Auto-generated method stub
List<String> list = new ArrayList<String>();
while(arg1.hasNext())
{
list.add(arg1.next()+" "+arg0); }
return list.iterator();
}
}, true);//参数的含义:true的含义就是是否进行shuffle。默认是不进行shuffle
coalesce.foreach(new VoidFunction<String>() { @Override
public void call(String arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(" "+ arg0);
}
});
} }

 5.floatmap

package kw.test.action;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.VoidFunction; /*
* 先执行一个map操作,然后将数据flat压扁
*/
public class FlatMap {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("FlatMap").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<String> list = Arrays.asList("wo am xues","ni shi la ji ","zha zs","zha df");
JavaRDD<String> javaRDD = javaSparkContext.parallelize(list);
JavaRDD<String> result = javaRDD.flatMap(new FlatMapFunction<String, String>() { @Override
public Iterator<String> call(String arg0) throws Exception {
// TODO Auto-generated method stub
//首选将数据分割,然后将和数据值机型压扁。
return Arrays.asList(arg0.split(" ")).iterator();
}
});
result.foreach(new VoidFunction<String>() { @Override
public void call(String arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg0);
}
}); } }

6.mappartition

package kw.test.action;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.VoidFunction; public class MapPartition {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("MapPartition").setMaster("local");
JavaSparkContext sparkContext = new JavaSparkContext(sparkConf);
List<String> list = Arrays.asList("wo","shi","lal","woowj","dffdds");
JavaRDD<String> javaRDD = sparkContext.parallelize(list); JavaRDD<String> result = javaRDD.mapPartitions(new FlatMapFunction<Iterator<String>, String>() { //将partition的数据全部给map,然后使用迭代器处理
@Override
public Iterator<String> call(Iterator<String> arg0)throws Exception {
// TODO Auto-generated method stub
List<String> list = new ArrayList<String>();
while(arg0.hasNext() )
{
list.add(arg0.next());
}
return list.iterator();
}
});
result.foreach(new VoidFunction<String>() { @Override
public void call(String arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg0);
}}); } }

  7.MapPartitionsWithIndex

package kw.test.action;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.VoidFunction; /*
*k可以获取到里面的分区位置
*/
public class MapPartitionsWithIndex {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("MapPartitionsWithIndex").setMaster("local");
JavaSparkContext sparkContext =new JavaSparkContext(sparkConf); List<String> list = Arrays.asList("kang","wang","ddd","kang1","wang2","ddd3");
JavaRDD<String> javaRDD = sparkContext.parallelize(list,4); JavaRDD<String> javaRDD2 = javaRDD.mapPartitionsWithIndex(new Function2<Integer, Iterator<String>, Iterator<String>>() { @Override
public Iterator<String> call(Integer arg0, Iterator<String> arg1)
throws Exception {
// TODO Auto-generated method stub
List<String> list = new ArrayList<String>();
while(arg1.hasNext())
{
list.add(arg1.next()+" "+ arg0);
}
return list.iterator();
}
}, true);
javaRDD2.foreach(new VoidFunction<String>() { @Override
public void call(String arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg0);
}
});
}
}

  8.Reduce

package kw.test.action;

import java.util.Arrays;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2; public class Reduce {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("Reduce").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<Integer> list= Arrays.asList(1,2,3,4,5,6,7);
JavaRDD<Integer> num = javaSparkContext.parallelize(list);
int sum = num.reduce(new Function2<Integer, Integer, Integer>() { @Override
public Integer call(Integer arg0, Integer arg1) throws Exception {
// TODO Auto-generated method stub
return arg0+arg1;
}
});
System.out.println("最终结果:"+sum);
} }

9.ReduceByKey

package kw.test.action;

import java.util.Arrays;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.VoidFunction; import scala.Tuple2; /*
* ReduceByKey是一个shuffle操作
*
* 在shuffle的时候,分为map端和reduce端
*
* spark里面的reduceByKey在map端映带conbiner。
* 也就是在map中处理然后将其累加,减少了网络的传输,效率更高。
*/
public class ReduceByKey {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("Reduce").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<Tuple2<String, Integer>> list= Arrays.asList(new Tuple2<String,Integer>("kang",),
new Tuple2<String,Integer>("kang",),
new Tuple2<String,Integer>("kang",),
new Tuple2<String,Integer>("kang",),
new Tuple2<String,Integer>("wang",));
JavaPairRDD<String, Integer> num = javaSparkContext.parallelizePairs(list);
JavaPairRDD<String, Integer> rr = num.reduceByKey(new Function2<Integer, Integer, Integer>() { @Override
public Integer call(Integer arg0, Integer arg1) throws Exception {
// TODO Auto-generated method stub
return arg0+arg1;
}
});
rr.foreach(new VoidFunction<Tuple2<String,Integer>>() { @Override
public void call(Tuple2<String, Integer> arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg0);
}
});
} }

10.RePartition

package kw.test.action;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.VoidFunction; /*
* repartition算子,用于任意数据量RDD的partition增多或者减少。
* coalesce仅仅将RDD的数量减少【其实不是这样的】
* 、
*
* 建议使用的场景:
* 一个很经典的场景,使用spark SQL从HIVE中查询数据的时候,spark SQLhui
* 会根据HIVE对应的hdfs文件的block的数量决定加载出来的RDD的个数是
* 多少个,这里默认的partition的数量是我们根本无法设置的
*
*
* 有的时候,可能他会自动的设置partition的数量过于少,就进行优化
* 可以提高并发度,就是对RDD使用的partition的算子。
*
*
* 一般情况下,我们为了减少shuffle的时候,我们首选使用coalesce
* 因为他可以避免shuffle操作。
*
*
*/
public class RePartition {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("Coalesce").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<Integer> list = Arrays.asList(1,2,3,4,5,6); JavaRDD<Integer> numbers = javaSparkContext.parallelize(list); JavaRDD<String> result = numbers.mapPartitionsWithIndex(new Function2<Integer, Iterator<Integer>, Iterator<String>>() { @Override
public Iterator<String> call(Integer arg0, Iterator<Integer> arg1)
throws Exception {
// TODO Auto-generated method stub List<String> list = new ArrayList<String>();
while(arg1.hasNext())
{
list.add(arg1.next()+" "+arg0);
}
return list.iterator();
}
}, true);
result.foreach(new VoidFunction<String>() { @Override
public void call(String arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg0+" ");
}
}); result.repartition(5);
JavaRDD<String> result2 = result.mapPartitionsWithIndex(new Function2<Integer, Iterator<String>, Iterator<String>>() { @Override
public Iterator<String> call(Integer arg0, Iterator<String> arg1)
throws Exception {
// TODO Auto-generated method stub
List<String> list = new ArrayList<String>();
while(arg1.hasNext())
{
list.add(arg1.next()+" "+arg0);
}
return list.iterator();
} }, true);
result2.foreach(new VoidFunction<String>() { @Override
public void call(String arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg0+" ");
}
});
} }

11.Sample

package kw.test.action;

import java.util.Arrays;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.VoidFunction; /*
* 随机采样从,可以传入一个Float,不如数0.3就是采样30%
* 比如说我在测试的时候使用的是5个单词,最后也就显示的是1个,当然了 Float的值是可以修改的,参数的个数也是可以自己给定的。
*
* 这个也可以设置partition的个数,如果是一个就先手wordnum*float,如果是两个的时候,他们的值是每一个里面取出wordNum*float的值
*/
public class Sample {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("sample").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<String> list = Arrays.asList("kwang","wang","is","a","student");
JavaRDD<String> num = javaSparkContext.parallelize(list);
//参数:false就是抽取之后,不会将数据放回,最终的结果是不会有重复的,如果是true会将数据放回再次抽取,最终结果就会有重复的。
//它的第三个参数,种子,如果不指定就会自动产生一个种子,所以每次的结果都是不一样的,但是如果指定一个种子
//那么它的最终的结果都是一样的。此参数一般作为测试使用。
num.sample(false, 0.8).foreach(new VoidFunction<String>() { @Override
public void call(String arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg0);
}
});
} }

12.Take

package kw.test.action;

import java.util.Arrays;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext; /*
* take是取数据,参数是几,我们就取其中的几个参数出来
*/
public class Take {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("take").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<String> list = Arrays.asList("kang","wang","lala");
JavaRDD<String> result = javaSparkContext.parallelize(list);
/*
* List<String> list1 = Arrays.asList("kang","wang","lala");
List<Integer> list = Arrays.asList(1,2,3,4,5);
JavaRDD<Integer> result = javaSparkContext.parallelize(list);
JavaRDD<String> result1 = javaSparkContext.parallelize(list1);
result.take(2);
result1.take(num); */
List<String> name = result.take();
for(String value :name)
{
System.out.println(value);
}
} }

13.TakeSample

package kw.test.action;

import java.util.Arrays;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext; /*
* take是取出数据,sample是随机的取出数据
*
* takeSample先进行sample在进行采样
*/
public class TakeSample {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("takesample").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<String> list = Arrays.asList("kang1","wang1","lala1","kang2","wang2","lala2","kang3","wang3","lala3");
JavaRDD<String> result = javaSparkContext.parallelize(list);
//第一个参数是否放回,第二个参数是数据的个数,第三个参数是种子。 如果种子一样,每一次的数据都是一样的,如果种子不一样,每一次的参数都不一样。
List<String> value = result.takeSample(false, 3);
for(String v:value)
{
System.out.println(v);
}
}
}

14.Union

package kw.test.action;

import java.util.Arrays;
import java.util.List; import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.VoidFunction; /*
* 将两个list变为一个list,他不会进行shuffle操作,加入开始都是两个partition,
* 将他们union之后,会是四个
*/
public class Union {
public static void main(String[] args) { // TODO Auto-generated method stub
SparkConf sparkConf = new SparkConf().setAppName("union").setMaster("local");
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
List<String> list1 = Arrays.asList("kang1","wang1","lala1","kang2","wang2","lala2");
List<String> list2 = Arrays.asList("kang3","wang3","lala3");
JavaRDD<String> result1 = javaSparkContext.parallelize(list1,2);
JavaRDD<String> result2 = javaSparkContext.parallelize(list2,2);
JavaRDD <String> unionre = result1.union(result2);
unionre.foreach(new VoidFunction<String>() { @Override
public void call(String arg0) throws Exception {
// TODO Auto-generated method stub
System.out.println(arg0);
}
});
}
}

  

spark算子(二)的更多相关文章

  1. UserView--第二种方式(避免第一种方式Set饱和),基于Spark算子的java代码实现

      UserView--第二种方式(避免第一种方式Set饱和),基于Spark算子的java代码实现   测试数据 java代码 package com.hzf.spark.study; import ...

  2. Spark(二)算子详解

    目录 Spark(二)算子讲解 一.wordcountcount 二.编程模型 三.RDD数据集和算子的使用 Spark(二)算子讲解 @ 一.wordcountcount 基于上次的wordcoun ...

  3. Spark算子总结及案例

    spark算子大致上可分三大类算子: 1.Value数据类型的Transformation算子,这种变换不触发提交作业,针对处理的数据项是Value型的数据. 2.Key-Value数据类型的Tran ...

  4. Spark算子总结(带案例)

    Spark算子总结(带案例) spark算子大致上可分三大类算子: 1.Value数据类型的Transformation算子,这种变换不触发提交作业,针对处理的数据项是Value型的数据. 2.Key ...

  5. Spark算子使用

    一.spark的算子分类 转换算子和行动算子 转换算子:在使用的时候,spark是不会真正执行,直到需要行动算子之后才会执行.在spark中每一个算子在计算之后就会产生一个新的RDD. 二.在编写sp ...

  6. Spark:常用transformation及action,spark算子详解

    常用transformation及action介绍,spark算子详解 一.常用transformation介绍 1.1 transformation操作实例 二.常用action介绍 2.1 act ...

  7. (转)Spark 算子系列文章

    http://lxw1234.com/archives/2015/07/363.htm Spark算子:RDD基本转换操作(1)–map.flagMap.distinct Spark算子:RDD创建操 ...

  8. UserView--第一种方式set去重,基于Spark算子的java代码实现

    UserView--第一种方式set去重,基于Spark算子的java代码实现 测试数据 java代码 package com.hzf.spark.study; import java.util.Ha ...

  9. spark算子之DataFrame和DataSet

    前言 传统的RDD相对于mapreduce和storm提供了丰富强大的算子.在spark慢慢步入DataFrame到DataSet的今天,在算子的类型基本不变的情况下,这两个数据集提供了更为强大的的功 ...

  10. Spark算子---实战应用

    Spark算子实战应用 数据集 :http://grouplens.org/datasets/movielens/ MovieLens 1M Datase 相关数据文件 : users.dat --- ...

随机推荐

  1. Windows学习总结(6)——MindManager新手入门教程

    MindManager新手入门教程 MindManager是一款创造.管理和交流思想的思维导图软件,其直观清晰的可视化界面和强大的功能可以快速捕捉.组织和共享思维.想法.资源和项目进程等等.MindM ...

  2. HDU 4975 A simple Gaussian elimination problem.

    A simple Gaussian elimination problem. Time Limit: 1000ms Memory Limit: 65536KB This problem will be ...

  3. Zabbix快速入门

    模板的管理与使用 一 模板 模板是zabbix的核心,因为模板继承了所有要监控的内容,以及所要展示的图形等等,zabbix的安装部署完成之后,自带了很多模板(网络设备模板,操作系统模板,常用应用软件模 ...

  4. POJ 1269 Intersecting Lines 直线交

    不知道谁转的计算几何题集里面有这个题...标题还写的是基本线段求交... 结果题都没看就直接敲了个线段交...各种姿势WA一遍以后发现题意根本不是线段交而是直线交...白改了那个模板... 乱发文的同 ...

  5. [BZOJ4555 TJOI2016 HEOI2016 求和]

    ​ 第一篇博客,请大家多多关照.(鞠躬 BZOJ4555 TJOI2016 HEOI2016 求和 题意: ​ 给定一个正整数\(n\)(\(1\leqq n \leqq100000\)),求: \[ ...

  6. ZJOI2008骑士

    Z国的骑士团是一个很有势力的组织,帮会中汇聚了来自各地的精英.他们劫富济贫,惩恶扬善,受到社会各界的赞扬. 最近发生了一件可怕的事情,邪恶的Y国发动了一场针对Z国的侵略战争.战火绵延五百里,在和平环境 ...

  7. 【Codecraft-18 and Codeforces Round #458 (Div. 1 + Div. 2, combined) B】 Conan and Agasa play a Card Game

    [链接] 我是链接,点我呀:) [题意] 在这里输入题意 [题解] 最大值出现次数是偶数. 那么就取次大值. 次大值也是偶数? =>再次 因为你绝对不能取偶数个的. 取了对方就总是能面对一个奇数 ...

  8. Java中JVM虚拟机详解

    1. 什么是JVM? JVM是Java Virtual Machine(Java虚拟机)的缩写,JVM是一种用于计算设备的规范,它是一个虚构出来的计算机,是通过在实际的计算机上仿真模拟各种计算机功能来 ...

  9. Maven和Ant的差别

    近期做的项目中一直是在使用maven.可是要知道最早出来的构建工具是Ant,如今Ant依旧有好多人再用.于是自己就抽出来时间.学习了一下Ant的主要的使用.这样也能跟好的理解Maven提供的新特性. ...

  10. cocos2d-x 一些3效果的类及创建參数

    CCShaky3D::create(时间,晃动网格大小,晃动范围,Z轴是否晃动); //创建一个3D晃动的效果 CCShakyTiles3D::create(时间,晃动网格大小,晃动范围,Z轴是否晃动 ...