泛型

Scala Java

def func1(a:String,b:Long): Tuple2[String,Long] =
  {
    val random=new Random()
    val prefix=random.nextInt(10)
    return Tuple2[String,Long](prefix + "_" + a,b)
  }

val randomPrefixRdd=pairs.map(x=>func1(x._1,x._2))

// 第一步，给RDD中的每个key都打上一个随机前缀。
    private static   PairFunction<Tuple2<String,Long>,String,Long> func1 = new PairFunction <Tuple2<String,Long>, String, Long>()
    {private static final long serialVersionUID = 1L;

public Tuple2<String, Long>call(Tuple2<String, Long> lalala)throws Exception //这个地方使用了函数模板，在java中称为范型
        {
            Random random = new Random();
            int prefix = random.nextInt(10);
            return new Tuple2<String, Long>(prefix + "_" + lalala._1, lalala._2);
        }
    };

JavaPairRDD<String,Long> randomPrefixRdd = pairs.mapToPair(func1);
val localAggrRdd = randomPrefixRdd.reduceByKey(_+_)

// 第二步，对打上随机前缀的key进行局部聚合。
private static Function2 <Long, Long,Long> func2=new Function2<Long,Long,Long>()
{ private static final long serialVersionUID = 1L;

public Long call(Long v1, Long v2) throws Exception
    {
        return v1+v2;
    }

};
// 第二步，对打上随机前缀的key进行局部聚合。
        JavaPairRDD<String, Long> localAggrRdd = randomPrefixRdd.reduceByKey(func2);

def func2(tuple:Tuple2[Long,String]):Iterator[Tuple2[String,String]]={
      var list: List[Tuple2[String,String]] = List()
      for(i<-0 until 100)
        list = list:+Tuple2[String, String](i + "_" + tuple._1,tuple._2)
      //      list.toIterator
      list.iterator
    }

val skewedRdd2 = rdd2.filter(v1=>v1._1.equals(skewedUserid)).flatMap(line=>func2(line))

 // rdd2，就是那个所有key的分布相对较为均匀的rdd。
// 这里将rdd2中，前面获取到的key对应的数据，过滤出来，分拆成单独的rdd，并对rdd中的数据使用flatMap算子都扩容100倍。
// 对扩容的每条数据，都打上0～100的前缀。
    JavaPairRDD<String, String> skewedRdd2 = rdd2.filter(new Function<Tuple2<Long, String>, Boolean>() {
        @Override
        public Boolean call(Tuple2<Long, String> v1) throws Exception {
            return v1._1.equals(skewedUserid);
        }
    }).flatMapToPair(new PairFlatMapFunction<Tuple2<Long, String>, String, String>()
    {
            @Override
            public Iterator<Tuple2<String, String>> call(Tuple2<Long, String> tuple) throws Exception
            {
//            Random random = new Random();
            List<Tuple2<String, String>> list = new ArrayList<Tuple2<String, String>>();
            for(int i = 0; i < 100; i++)
            {
                list.add(new Tuple2<String, String>(i+"_"+tuple._1,tuple._2));
            }
            return list.iterator();
            }
    }
            );

这里肯定有更简洁的泛型转换形式，上述只是一个初步的整理。

类型转化

Python2.7 Scala Java

a=111

long(a)

     def func1(s:String):(Long,String)=
    {
      val strings=s.split(",")
      val ids=strings(0).toLong
      val great=strings(1)
      Tuple2.apply(ids,great)
    }

JavaPairRDD<Long, String> rdd1 = sc.textFile(path1)
            .mapToPair(new PairFunction<String, Long, String>()
            {
                @Override
                public Tuple2<Long, String> call(String s) throws Exception
                {

String[] strings=s.split(",");

  Long ids = Long.valueOf(strings[0]);
                    String greet=strings[1];

return Tuple2.apply(ids,greet);
                }
            });

匿名函数-Lambda

  Python Scala Java
传入多个参数 a = lambda x,y,z:(x+8)*y-z
print(a(5,6,8))
 

object hello
{

def main(args: Array[String])
  {

// with multiple parameters
    val ex2 = (x:Int, y:Int,z:Int) => (x +8)*y-z
    println(ex1(7))
    println(ex2(2, 3,6))
  }
}

  
lambda表达式后面传参 (lambda x, y: x if x>y else y)(1, 2)

object hello
{

def main(args: Array[String])
  {
    val ex2 = (x:Int, y:Int,z:Int) => if(y<x){(x +8)*y-z}else{x+y+z}
    println(ex2(2, 3,6))

}

}

  

lambda函数本身做为return的值

 def add(n):
    return lambda x: x+n
f = add(1)
print(f(2)) 		无  
列表结合使用

L = [lambda x: x**2,\
     lambda x: x**3,\
     lambda x: x**4]
for x in L:
        print(x(2))

print("------------------------------")
print(L[0](2))

val a=List(1,2,3,4)
val lists1=List(a.map(x=>x*x),a.map(x=>x*x*x),a.map(x=>2*x*x))
    for( b <- 0 to lists1.size-1)
    {
      println(lists1(b))
    }

println(lists1(0))

  
字典配合使用 key = 'B'
dic = { 'A': lambda: 2*2,\
        'B': lambda: 2*4,\
        'C': lambda: 2*6}
print(dic[key]()) 		import scala.collection.immutable.HashMap
var hashMap2 = HashMap("A"->2*2, "B"->2*4, "C"->2*6)
var key = 'B'
println(hashMap2("B")) 		 
结合map函数使用 ​lists1=[1,2,3,4]
squares = map(lambda x: x**2, lists1)
print(list(squares)) 		val lists1=List(1,2,3,4)
val squares =lists1.map(x=>x*x)
println(squares) 		 
a = lambda x:x[1]
print(a([2,3,4]))

map(_._2)

  
a = lambda x,y:(x[1],y)
print(a([2,3,4],5))

map(_._2, _)

  
结合reduce函数使用 from functools import reduce
def add(x, y) : # 两数相加
    return x + y
print(reduce(add, [1,2,3,4,5]))
print(reduce(lambda x, y: x+y, [1,2,3,4,5]))

val list = List(1,2,3,4,5)
list.reduce(_+_)

  
结合filter函数使用 print(list(filter(lambda x: x%2==0,  [1,2,3,4,5,6])))

val x=List.range(1,10)
val evens=x.filter(_%2==0)

  
结合sorted函数使用 info = [('James',32), ('Alies',20), ('Wendy',25)]
print(sorted(info, key=lambda age:age[1]))# 按照第二个元素，索引为1排序 		val list=List(("James",32),("Alies",20),("Wendy",25))
println(list.sortBy(_._2)) 		 
reduce聚合(求和) print(reduce(lambda x,y:sum([x,y]),range(1,101))) val result = List.range(1,101).reduce((x,y)=>(x+y))
println(result) 		 
map映射 print(list(map(lambda x,y:sum([x,y]),range(1,101),range(1,101))))     val x = List.range(1,101)
    val y = List.range(1,101)
    val result1=x.zip(y).map(t => t._1 + t._2)
    val result2=(x,y).zipped.map(_ + _)
    println(result1)
    println(result2) 		 
要点

①lambda 函数不能包含命令，

②包含的表达式不能超过一个。

③lambda 并不会带来程序运行效率的提高，只会使代码更简洁。

  

Reduce和Map区别

  参数方面 作用规律
map函数 map()包含两个参数，第一个是参数是一个函数，第二个是序列（列表或元组）。其中，函数（即map的第一个参数位置的函数）可以接收一个或多个参数。 将传入的函数依次作用到序列的每个元素，每个元素都是独自被函数“作用”一次；
reduce函数 第一个参数是函数，第二个是 序列（列表或元组）。但是，其函数必须接收两个参数。 将传人的函数作用在序列的第一个元素得到结果后，把这个结果继续与下一个元素作用（累积计算）， 最终结果是所有的元素相互作用的结果。

map/reduce/foreach代码实例

函数 示例代码1(foreach模仿reduce效果) 示例代码2(foreach模仿map效果)
map

val v = Vector(1,2,3,4)

var sum = 0

var s = v.map(n => n+n)

println(s)

//输出：Vector(2, 4, 6, 8)

 如下面的
reduce

val v2 = Vector(1,2,3,4)

var v3 = v2.reduce((sum,n) => sum + n)

println(v3) //输出：10

 无
foreach val vv = Vector(1,2,3,4)
var sum1 = 0//事先设定一个全局变量
vv.foreach( n => sum1 += n)
println(sum1)//输出：10 		object hello
{
  def main(args:Array[String])
  {
    var increase=(x:Int)=>x+1
    val someNumbers = List( -11, -10, -5, 0, 5, 10)
    var c = someNumbers.map(increase)
    c.foreach((x:Int)=>print(x+" "))
    println()
    c.map((x:Int)=>print(x+" "))
  }
}

while循环

Python Scala Java
x=10;
while x<20:
    print("Value of x",x)
    x=x+1; 		var x=10;    
while( x < 20 )
{
println( "Value of x: " + x );
x=x+1;
}

int x=10

while( x < 20 )

{

System.out.print("value of x : " + x );

x++;

System.out.print("\n");

}

for循环

Python Scala Java
lst = [1,2,3,4,5,6]
for index,value in enumerate(lst):
    print ('%s,%s' % (index,value)) 		object Test {
   def main(args: Array[String]) {
      var a = 0;
      // for 循环
      for( a <- 1 to 10){
         println( "Value of a: " + a );
      }
   }
}

public class Test {

public static void main(String args[])

{

for(int x = 10; x < 20; x = x+1)

{ System.out.print("value of x : " + x ); System.out.print("\n");

}

}

}

List列表

  Python Scala Java
空List a = [] val a = List() //List[Nothing] List<Integer> list = new ArrayList<Integer>();
Int a = [1,2,3,4,5] val a = List(1,2,3,4,5) Integer a[] = {1,2,5,6,9};
List<Integer> list = new ArrayList<>();
System.out.println(list.size());
Collections.addAll(list, a);
String a = ["a", "b"] val a: List[String] = List("Hello", "World") List<String> list = new ArrayList<String>();
不同类型 a = [1,"Hello"] val a = List(1, "Hello") //List[Any] List<Integer> list = new ArrayList<Integer>();
list.add(1);
2维 a = [[1,2,3], [4,5,6]] val a = List(List(1,2,3), List(4,5,6))  
索引 a[10] a(10) System.out.println(list1.get(1))
截取 a[0:2] a.slice(0,2) List<String>subList = list.subList(3,5);
是否为空 not a a==[] len(a)==0 a.isEmpty System.out.println(list1.isEmpty());
append a.append(6) a :+ 6 list.add(1);
连接 a.extend([4,5,6]) List.concat(List(1,2,3), List(4,5,6)) List<String> a=new ArrayList<String>();
List<String> b=new ArrayList<String>();
b.addAll(a)
反转 a[::-1] a.reverse Collections.reverse(list1);
System.out.println(list1);
获取元素索引

aList = [123, 'xyz', 'runoob', 'abc']

aList.index( 'xyz' )

 List("Mary","had","a","little","lamb").indexOf("little") System.out.println(list1.indexOf(5));

HashMap

功能 Python Scala Java
新建 map = {"one": 1, "two":2} val map = Map("one"->1, "two"->2)

import java.util.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;

HashMap<String, String> map = new HashMap<>();
map.put("zhang", "31");//存放键值对
val map = Map(("one", 1), ("two", 2))
获取 map["one"] map("one") System.out.println(map.get("zhang"));//获取值
包含 "one" in map map.contains("one") System.out.println(map.containsKey("zhang"));
添加 map["three"] = 3 map + ("three"->3) map.put("zhang", "31");
删除 del map["three"] map - "three" System.out.println(map.remove("zhang"));
keys map.keys() map.keys  
values map.values() map.values  
concat map1.update(map2) map1 ++ map2  
判空  if dict:
    print 'not Empty'

val m1 = Map(3 -> "geeks", 1 -> "for", 2 -> "cs", 3 -> "geeks")

val result = m1.isEmpty

 System.out.println(map.isEmpty());//判空

Set

  Python Scala Java
新建

s = {1,2,3}

s = set([1,2,3])

 val s = Set(1,2,3) Set<Integer> set = new HashSet<Integer>();
添加 s.add(4) s + 4 set.add(6);
删除 s.remove(4) s - 4 set.remove(9);
是否为空 not s s.isEmpty HashSet hs1 = new HashSet();
System.out.println(hs1.isEmpty());
hs1.add("苹果");
hs1.add("梨");
System.out.println(hs1.isEmpty());
min min(s) s.min

import java.util.HashSet;
import java.util.Iterator;
import java.util.Collections;
import java.util.Set;
public class Main
 {
    public static void main(String[] args)
    {
//        HashSet hs1=new HashSet("231","1212");
        Set<Integer> set = new HashSet<Integer>();
        set.add(3);
        set.add(6);
        set.add(2);
        set.add(9);

// printing the Set
        System.out.println("Set: " + set);

// getting minimum value
        // using min() method
        int minSet = Collections.min(set);
        // getting maximum value
        // using max() method
        int maxSet = Collections.max(set);
        // printing the minimum value
        System.out.println("Minimum value of set is: "
                + minSet);
        // printing the maximum value
        System.out.println("Maximum value of set is: "
                + maxSet);
    }
}
max max(s) s.max 同上
交集 x = set('spam')
y = set(['h','a','m'])
x & y # 交集  

scala> Set(1,2,3) & Set(2,4) // &方法等同于interset方法

scala> Set(1,2,3) intersect Set(2,4)

import java.util.HashSet;
import java.util.Iterator;
public class Main {
    public static void main(String[] args)
    {
        //Set 集合存和取的顺序不一致。
        HashSet hs1 = new HashSet();
        hs1.add("苹果");
        hs1.add("梨");

HashSet hs2 = new HashSet();
        hs2.add("梨");
        hs2.add("香蕉");
        HashSet result=new HashSet();
        result.addAll(hs1);
        result.retainAll(hs2);//交集运算
        Iterator it = result.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
差集
x - y # 差集  
 

scala> Set(1,2,3) -- Set(2,4) //得到 Set(1,3)

scala> Set(1,2,3) &~ Set(2,4)

scala> Set(1,2,3) diff Set(2,4)

import java.util.HashSet;
import java.util.Iterator;
public class Main {
    public static void main(String[] args)
    {
        //Set 集合存和取的顺序不一致。
        HashSet hs1 = new HashSet();
        hs1.add("苹果");
        hs1.add("梨");

HashSet hs2 = new HashSet();
        hs2.add("梨");
        hs2.add("香蕉");
        HashSet result=new HashSet();
        result.addAll(hs1);
        result.removeAll(hs2);//交集运算
        Iterator it = result.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
并集 >>> x.union(y)
{'p', 'a', 's', 'm', 'h'}
>>> x|y
{'p', 'a', 's', 'm', 'h'} 		s1.union(s2) import java.util.HashSet;
import java.util.Iterator;
public class Main {
    public static void main(String[] args)
    {
        //Set 集合存和取的顺序不一致。
        HashSet hs1 = new HashSet();
        hs1.add("世界军事1");
        HashSet hs2 = new HashSet();
        hs2.add("世界军事2");
        hs1.addAll(hs2);
        Iterator it = hs1.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
s1 ++ s2

For loop

  Python Scala Java
Range for x in range(5): print(x) for(x <- Range(1, 5)) println(x)

public class Main
{
public static void main(String[] args)
{
for (int x : new Range(10, 0, -1)) 
{
System.out.println(x);
}
}

};

其中Range类需要自定义
List for x in li: print(x) for (x <- li) println(x)

import java.util.*;

public class Main {
    public static void main(String[] args)
    {

List<String> strList = new ArrayList<>();
        strList.add("aaa");
        strList.add("bbb");
        strList.add("ccc");
        // 1. 普通遍历方式
        for (int i = 0; i < strList.size(); i++) {
            System.out.println(strList.get(i));
        }
        // 2.增强的for循环
        for (String str : strList) {
            System.out.println(str);
        }
        // 3. 使用Iterator迭代器
        Iterator<String> it = strList.iterator();
        while (it.hasNext()) {
            String str = (String) it.next();
            System.out.println(str);
        }
        // 4. java8 Lambda方式
        // strList.forEach(System.out::println);//和下面的写法等价
        strList.forEach(str -> {
            System.out.println(str);
        });

}
}
Map for k, v in map1.items(): print(k,v) for ((k,v) <- map1) println(k, v)

import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("1", "value1");
        map.put("2", "value2");
        map.put("3", "value3");

//第一种：普遍使用，二次取值
        System.out.println("通过Map.keySet遍历key和value：");
        for (String key : map.keySet())
        {
            System.out.println("key= "+ key + " and value= " + map.get(key));
        }

}
}

Range

Python Scala Java
range(1, 10) (inclusive, exclusive) Range(1, 10) (inclusive, exclusive)

public class Main
{
public static void main(String[] args)
{
for (int x : new Range(10, 0, -1)) 
{
System.out.println(x);
}
}

};

其中Range类需要自定义
无 1 to 10 (inclusive, inclusive) 同上
无 1 until 10 (inclusive, exclusive) 同上
range(10) (exclusive) 无 同上
range(1, 10, 2) 1 to 10 by 2 同上
仅支持int 1.0 to 10.0 by 0.5 同上
仅支持int 'a' to 'g' by 2 同上

列表推导式-List Comprehension

Python Scala Java
dogBreeds =["Doberman", "Yorkshire Terrier", "Dachshund","Scottish Terrier", "Great Dane","Portuguese Water Dog"]
filteredBreeds=[breed for breed in dogBreeds if "Terrier" in breed and not breed.startswith('Yorkshire')]
print(filteredBreeds)
  		val dogBreeds = List("Doberman", "Yorkshire Terrier", "Dachshund","Scottish Terrier", "Great Dane","Portuguese Water Dog")
val filteredBreeds = for {breed <- dogBreeds if breed.contains("Terrier") && !breed.startsWith("Yorkshire")} yield breed
println(filteredBreeds) 		无

Main函数写法

Python Scala Java

def main():
    print("hello world")

if __name__ == '__main__':
    main()

 object HelloWorld{ def main(args : Array[String]){ println("HelloWorld") } } public class HelloWorld 
{
    public static void main(String[] args) 
{ 
System.out.println("Hello World"
);
    }
}

迭代器

Python Scala Java

import sys         # 引入 sys 模块
list=["Baidu", "Google", "Runoob", "Taobao"]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:

 object Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
      
      while (it.hasNext){
         println(it.next())
      }
   }
} 		import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import static java.lang.Thread.yield;
public class Main
{
    public static void main(String[] args)
    {
        List<String> lst = new ArrayList<String>();
        lst.add("Baidu");
        lst.add("Google");
        lst.add("Runoob");
        lst.add("Taobao");
        Iterator<String> iterator = lst.iterator();
        //iterator.hasNext()如果存在元素的话返回true
        while(iterator.hasNext()) {
            //iterator.next()返回迭代的下一个元素
            System.out.println(iterator.next());
        }
    }

生成器

Python Scala Java

g = (x * x for x in range(10))

print(g)
print(g.__next__())

 val result=for(x <-List.range(1, 10))yield (x)
println(result.getClass().getSimpleName())

import static java.lang.Thread.yield;
public class Main
{
    public static void main(String[] args)
    {
        System.out.println("Hello World!");
        Generator<Integer> simpleGenerator = new Generator<Integer>()
        {
            public void run() throws InterruptedException
            {
                for(int x = 10; x < 20; x = x+1)
                    yield(x);
            }
        };
        for (Integer element : simpleGenerator)
            System.out.println(element);
    }
};

Generator在java标准库中没有，

需要另外自定义

case class

Scala Java 
case class Order(user: Long, product: String, amount: Int)
 
public class Order {public Long user;public String product;public int amount;public Order() {}public Order(Long user, String product, int amount) {this.user = user;this.product = product;this.amount = amount;}@Overridepublic String toString() {return "Order{" +"user=" + user +", product='" + product + '\'' +", amount=" + amount +'}';}
}
   

凡是上面记载不全的地方，一定要注意掌握[12]

Reference

[1]给Python程序员的Scala入门教程

[2]Scala学习日志（三）——轻便神奇的for推导式

[3]python中lambda的用法

[4]Scala编程 Lambda Expressions

[5]scala中的Lambda表达式

[6]map函数和reduce函数的区别

[7]Lambda Expression in Scala

[8]Scala 中的foreach和map方法比较

[9]遍历HashMap的四种方式

[10]Java中HashMap的用法

[11]java 两个list合并

[12]使用intellij查看scala变量的具体类型

Python和Scala和Java的语法对照表(持续更新中)相关推荐

  1. Java自学视频整理(持续更新中...)

    1.Java基础视频 <张孝祥JAVA视频教程>完整版[RMVB](东西网) 历经5年锤炼(史上最适合初学者入门的Java基础视频)(传智播客) 张孝祥2010年贺岁视频:Java高新技术 ...

  2. 《LeetCode 热题 HOT 100》Java答案汇总版---持续更新中

    <LeetCode 热题 HOT 100>Java答案汇总版-持续更新中 个人认为<LeetCode 热题 HOT 100>中的题目特别适合算法新手进行一个入门的刷题,而且作者 ...

  3. 《python编程从入门到实践》python入门级-学习笔记（1-2章）——持续更新中

    CSDN的小伙伴们你们好~从今天起我开始自学编程了. 恭喜你关注到一个成长型账号. 一以来作为美术出身的TA,我无数次的向往能打出几行属于自己的代码.为了跟上时代的步伐,也为了能更加深入TA这个职业, ...

  4. python中text函数的语法_Python语法大全(持续更新中ing)

    1.type()函数可以返回任何Python定义的数据类型. Python提供了一些数字类型转换函数:int().long().float().complex().整数.长整数和浮点数可以通过comp ...

  5. Python学习小甲鱼视频做的笔记(持续更新中)

    Python BIF :Built-in functions(内建函数) Python与大多数其他计算机语言的做法稍有不同,他并不是把值存储在变量中,而更像是把名字贴在值的上边. 在使用变量之前,必须 ...

  6. Java基础细节（持续更新中）

    一.JDK 和 JRE 二.开发步骤 步骤: 1. 将 Java 代码编写到扩展名为 .java 的文件中. 2. 通过 javac 命令对该 java 文件进行编译. 3. 通过 java 命令对生 ...

  7. 我学习 Java 的历程和体会（写给新手看，欢迎老司机批评和建议，持续更新中）

    我学习 Java 的历程和体会(写给新手看,欢迎老司机批评和建议,持续更新中) 最初写这篇文章的时候,是在今年的 9 月中旬.今天,我想再写写这将近两个多月以来的感受. 在今年的 10 月我来到北京求 ...

  8. 面试JAVA常被问到的问题（持续更新中）

    引言 有的面试会被问到有没有写博客,这时候我尴尬,不知道怎么回答,所以这篇文章仅仅是把我面试JAVA的遇到的问题记录下来而已,也算是我写博客迈出的第一步,起码,以后被问到:有没有写博客?我可以回答,我 ...

  9. 面试1：Java、微服务、架构常见面试题（持续更新中）

    Java.微服务.架构常见面试题(持续更新中) 文章目录 Java.微服务.架构常见面试题(持续更新中) ==**Java**== 1.Java概述 (1)JVM.JRE和JDK (2)Java特点 ...

最新文章

  1. 啥？Transformers又来刷CV的榜了？
  2. android横竖屏切换生命周期
  3. P2286 [HNOI2004]宠物收养场
  4. LINUX下使用https访问站点
  5. SoapUI 测试http接口实战
  6. 05_Grafana的安装和Influxdb数据源配置
  7. 地震勘探英文专业文章中的经典句子（1）
  8. 什么是 ARM 架构处理器？
  9. 成功的人和不成功的人最大的区别
  10. nltk 中的 sents 和 words
  11. 数学连乘和累加运算符号_2020中考数学 初中数学有理数计算（干货）
  12. HDOJ--1203--I NEED A OFFER!
  13. Python import其他文件夹的文件
  14. SAP接口编程 之 JCo3.0系列：JCoDestination
  15. OpenBSD 7.2版发布 新增苹果M2芯片和高通骁龙8cx芯片组的支持
  16. php写前端还是nodejs,javascript - 新手想在短期内写一个个人博客，是用php还是用nodejs？...
  17. s32k144 isystem linux,S32K144之时钟配置
  18. java postgresql date_javapostgresql时区总结
  19. BMFont制作字体
  20. 外国人最习惯用的社交软件有哪些？

热门文章

  1. 2020年，ICPC比赛、CCPC比赛、CCF-CSP考试、蓝桥杯比赛、天梯赛日程
  2. web自动化实现文件上传
  3. 转——图像锐化算法原理
  4. 深度学习实战-使用Kera预测人物年龄
  5. html 加载转圈功能
  6. Flex Chart技巧-移除浮水印
  7. 城市售票网验证码图片的获取
  8. 【关于时间序列的ML】项目 5 ：用机器学习预测天气
  9. 这几个好用的文本翻译工具推荐给你
  10. ios 百度地图指定区域_IOS 百度地图定位,显示地理位置