流行编程语言的详细对比(8)--容器类

容器类
Java
接口 list set map介绍与简单对比

List：关心的是顺序，它保证维护元素特定的顺序（允许有相同元素），使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素。即可以通过下标 (1,2…) 来取得值，值可以重复。

Set：仅接受一次，并做内部排序。只关心某元素是否属于 Set （不允许有相同元素），而不关心它的顺序。只能通过游标来取值，并且值是不能重复的。

Map：最大的特点是键值映射，且为一一映射，键不能重复，值可以，所以是用键来索引值。 方法 put(Object key, Object value) 添 加一个"值" ( 想要得东西 ) 和与"值"相关联的"键" (key) ( 使用它来查找 ) 。方法 get(Object key) 返回与给定"键"相关联的"值" Map同样对每个元素保存一份，但这是基于 "键 " 的， Map也有内置的排序，因而不关心元素添加的顺序。

简单来说 如果是注重顺序，优选实现了list接口的容器。注重键值管理，优选实现了map接口的容器，如果是单纯集合处理 就选实现了set接口的容器。

list set map实现类的介绍与简单对比

初级实现类 底层实现 特点 同步 安全性
LinkedList ，链表，插入删除，没有同步，线程不安全
ArrayList ，数组，随机访问， 没有同步， 线程不安全
Vector ，数组 ， 线程安全， 同步， 线程安全
HashSet，HashMap， Set中效率高， 没有同步， 线程不安全
TreeSet，TreeMap， 固定的顺序 ，没有同步， 线程不安全
Hashtable，vector， 不能存储null值 ，有初始容量和负载因子， 同步 ，线程安全
HashMap ，哈希表， 可以存储null ， 没有同步 ，线程不安全
TreeMap，红黑树， 总处于平衡状态， 没有同步， 线程不安全

Js

var cars=new Array();
cars[0]="Saab";
cars[1]="Volvo";
cars[2]="BMW";
或者 (condensed array):
var cars=new Array("Saab","Volvo","BMW");
或者 (literal array):
实例
var cars=["Saab","Volvo","BMW"];

ES6新增数据结构：Set,Map,WeakSet,WeakMap
WeakMap和Map,Weakset和Set大体上一样，但是有两个重大区别：
1.WeakMap,WeakSet 的成员只能是对象，而不能是其他类型的值。
2.WeakMap,WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于WeakMap, WeakSet 之中。

Python
序列: str 可用’ "定义, unicode, list[], tuple()
字典: dict{}
dict1 = {‘name’ : ‘LiuZhichao’, ‘age’ : 24}
集合: set, frozenset　
set1 = {1, 2, 3, 4, 5}

Go
内置容器： 数组(Array) 、切片(Slice)、映射(map)
扩展容器：container 包实现了堆，链表，环（heap、list 和 ring）

这里介绍最常用的Map
Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
定义 Map可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对
实例
下面实例演示了创建和使用map:

package main
import "fmt"

func main() {
   var countryCapitalMap map[string]string
   /* 创建集合 */
   countryCapitalMap = make(map[string]string)
   
   /* map 插入 key-value 对，各个国家对应的首都 */
   countryCapitalMap["France"] = "Paris"
   countryCapitalMap["Italy"] = "Rome"
   countryCapitalMap["Japan"] = "Tokyo"
   countryCapitalMap["India"] = "New Delhi"
   
   /* 使用 key 输出 map 值 */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* 查看元素在集合中是否存在 */
   captial, ok := countryCapitalMap["United States"]
   /* 如果 ok 是 true, 则存在，否则不存在 */
   if(ok){
      fmt.Println("Capital of United States is", captial)  
   }else {
      fmt.Println("Capital of United States is not present") 
   }
}

以上实例运行结果为：
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of India is New Delhi
Capital of United States is not present

Scala

// 定义整型 List，List的特征是其元素以线性方式存储，集合中可以存放重复对象。
val x = List(1,2,3,4)

// 定义 Set，Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象
var x = Set(1,3,5,7)

// 定义 Map，Map 是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)

// 创建两个不同类型元素的元组
val x = (10, "Runoob")

// 定义 Option，元组是不同类型的值的集合
val x:Option[Int] = Some(5)

//迭代器不是一个容器，更确切的说是逐一访问容器内元素的方法。
object Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
      
      while (it.hasNext){
         println(it.next())
      }
   }
}

PHP

<?php
$cars=array("Volvo","BMW","SAAB");
$cars[0]="Volvo";
$cars[1]="BMW";
$cars[2]="SAAB";

$arrlength=count($cars);

for($x=0;$x<$arrlength;$x++) {
  echo $cars[$x];
  echo "<br>";
}
?>

<?php
$age=array("Bill"=>"35","Steve"=>"37","Peter"=>"43");
$age['Peter']="35";
$age['Ben']="37";
$age['Joe']="43";
foreach($age as $x=>$x_value) {
  echo "Key=" . $x . ", Value=" . $x_value;
  echo "<br>";
}
?>

function cube($n)
{
    return($n * $n * $n);
}

$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b)