在現(xiàn)實中經(jīng)常需要處理大量同類的數(shù)據(jù)揽思，如果一個一個表示就太麻煩了袜腥，如能“一組一組”表示會方便很多。于是就有了“數(shù)組”钉汗。

各種編程語言幾乎都有數(shù)組（或類似的數(shù)據(jù)結(jié)構(gòu)）羹令。除此之外，還有表损痰、字典福侈、元組之類的類似結(jié)構(gòu)。而字符串卢未，往往也是用數(shù)組的結(jié)構(gòu)來存放肪凛。

C語言數(shù)組

我們知道，要想把數(shù)據(jù)放入內(nèi)存辽社，必須先要分配內(nèi)存空間伟墙。放入4個整數(shù)，就得分配4個int類型的內(nèi)存空間：int a[4];這樣滴铅，就在內(nèi)存中分配了4個int類型的內(nèi)存空間戳葵，共 4×4=16 個字節(jié)，并為它們起了一個名字汉匙，叫a拱烁。我們把這樣的一組數(shù)據(jù)的集合稱為數(shù)組（Array），它所包含的每一個數(shù)據(jù)叫做數(shù)組元素（Element）噩翠，所包含的數(shù)據(jù)的個數(shù)稱為數(shù)組長度（Length）戏自，例如int a[4];就定義了一個長度為4的整型數(shù)組，名字是a伤锚∑滞看看，不但節(jié)省了代碼见芹，而且節(jié)省了命名剂娄。

數(shù)組不但簡化了表示，而且提高了操作效率玄呛。數(shù)組中的每個元素都有一個序號阅懦，這個序號從0開始，而不是從我們熟悉的1開始徘铝，稱為下標(biāo)（Index）耳胎。使用數(shù)組元素時，指明下標(biāo)即可惕它，形式為：arrayName[index]
arrayName 為數(shù)組名稱怕午，index 為下標(biāo)。例如淹魄，a[0] 表示第0個元素郁惜，a[3] 表示第3個元素。這樣甲锡，數(shù)組就變得可索引了兆蕉。

接下來我們就把第一行的4個整數(shù)放入數(shù)組：a[0]=20;a[1]=345;a[2]=700;a[3]=22;
這里的0、1缤沦、2虎韵、3就是數(shù)組下標(biāo)，a[0]缸废、a[1]包蓝、a[2]、a[3] 就是數(shù)組元素企量。我們來總結(jié)一下數(shù)組的定義方式：dataType arrayName[length];
dataType 為數(shù)據(jù)類型测萎，arrayName 為數(shù)組名稱，length 為數(shù)組長度梁钾。例如：float m[12];char ch[9];
注意：1) 數(shù)組中每個元素的數(shù)據(jù)類型必須相同绳泉，對于int a[4];，每個元素都必須為 int姆泻。2) 數(shù)組下標(biāo)必須是整數(shù)零酪，取值范圍為 0 ≤ index < length。3) 數(shù)組是一個整體拇勃，它的內(nèi)存是連續(xù)的四苇，下面是int a[4];的內(nèi)存示意圖：

注意，在內(nèi)存中是連續(xù)存放的方咆，所以節(jié)省空間月腋，尋址快速。

數(shù)組的初始化
上面的代碼是先定義數(shù)組再給數(shù)組賦值，我們也可以在定義數(shù)組的同時賦值：

int a[4] = {20, 345, 700, 22};

{ }中的值即為各元素的初值榆骚，各值之間用,間隔片拍。對數(shù)組賦初值需要注意以下幾點：

1. 可以只給部分元素賦初值。當(dāng){ }中值的個數(shù)少于元素個數(shù)時妓肢，只給前面部分元素賦值捌省。例如：

   int a[10]={12, 19, 22 , 993, 344};

表示只給 a[0]~a[4] 5個元素賦值，而后面5個元素自動賦0值碉钠。當(dāng)賦值的元素少于數(shù)組總體元素的時候纲缓，剩余的元素自動初始化為 0：對于short、int喊废、long祝高，就是整數(shù)0；對于char污筷，就是字符 '\0'工闺；對于float、double颓屑，就是小數(shù)0.0斤寂。我們可以通過下面的形式將數(shù)組的所有元素初始化為 0：

int a[10] = {0};
char c[10] = {0};
float f[10] = {0};

由于剩余的元素會自動初始化為0，所以只需要給第0個元素賦0值即可揪惦。
示例：輸出數(shù)組元素遍搞。

#include <stdio.h>
int main()
{
  int a[6] = {299, 34, 92, 100};
  int b[6], i;
  //從控制臺輸入數(shù)據(jù)為每個元素賦值
  for(i=0; i<6; i++){
    scanf("%d", &b[i]);
  }
  //輸出數(shù)組元素
  for(i=0; i<6; i++){
    printf("%d ", a[i]);
  }
  putchar('\n');
  for(i=0; i<6; i++){
    printf("%d ", b[i]);
  }
  putchar('\n');

  return 0;
}

2. 只能給元素逐個賦值，不能給數(shù)組整體賦值器腋。例如給十個元素全部賦1值溪猿，只能寫為：

   int a[10]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

而不能寫為：int a[10]=1;

3. 如給全部元素賦值，那么在數(shù)組定義時可以不給出數(shù)組的長度纫塌。例如：

   int a[]={1,2,3,4,5};

等價于int a[5]={1,2,3,4,5};

二維數(shù)組

上節(jié)講解的數(shù)組可以看作是一行連續(xù)的數(shù)據(jù)诊县，只有一個下標(biāo)，稱為一維數(shù)組措左。在實際問題中有很多量是二維的或多維的依痊，因此C語言允許構(gòu)造多維數(shù)組。多維數(shù)組元素有多個下標(biāo)怎披，以確定它在數(shù)組中的位置胸嘁。本節(jié)只介紹二維數(shù)組，多維數(shù)組可由二維數(shù)組類推而得到凉逛。

二維數(shù)組定義的一般形式是：

dataType arrayName[length1][length2];

其中性宏，dataType 為數(shù)據(jù)類型，arrayName 為數(shù)組名状飞，length1 為第一維下標(biāo)的長度毫胜，length2 為第二維下標(biāo)的長度书斜。例如：int a[3][4];
定義了一個3行4列的數(shù)組，共有3×4=12個元素酵使，數(shù)組名為a荐吉，即：
a[0][0], a[0][1], a[0][2], a[0][3]
a[1][0], a[1][1], a[1][2], a[1][3]
a[2][0], a[2][1], a[2][2], a[2][3]
在二維數(shù)組中，要定位一個元素凝化，必須給出一維下標(biāo)和二維下標(biāo)稍坯，就像在一個平面中確定一個點，要知道x坐標(biāo)和y坐標(biāo)搓劫。例如，a[3][4] 表示a數(shù)組第3行第4列的元素混巧。二維數(shù)組在概念上是二維的枪向，但在內(nèi)存中地址是連續(xù)的，也就是說存儲器單元是按一維線性排列的咧党。那么秘蛔，如何在一維存儲器中存放二維數(shù)組呢？有兩種方式：一種是按行排列傍衡， 即放完一行之后順次放入第二行深员。另一種是按列排列， 即放完一列之后再順次放入第二列蛙埂。在C語言中倦畅，二維數(shù)組是按行排列的。也就是先存放a[0]行绣的，再存放a[1]行叠赐，最后存放a[2]行；每行中的四個元素也是依次存放屡江。數(shù)組a為int類型芭概，每個元素占用4個字節(jié)，整個數(shù)組共占用4×(3×4)=48個字節(jié)惩嘉。

【示例】一個學(xué)習(xí)小組有5個人罢洲，每個人有三門課的考試成績。求全組分科的平均成績和各科總平均成績文黎。

可設(shè)一個二維數(shù)組a[5][3]存放五個人三門課的成績惹苗。再設(shè)一個一維數(shù)組v[3]存放所求得各分科平均成績，設(shè)變量average 為全組各科總平均成績臊诊。編程如下：

#include <stdio.h>
int main(){
  int i, j; //二維數(shù)組下標(biāo)
  int sum=0; //當(dāng)前科目的總成績
  int average; //總平均分
  int v[3]; //各科平均分
  int a[5][3]; //用來保存每個同學(xué)各科成績的二維數(shù)組
  printf("Input score:\n");
  for(i=0; i<3; i++){
    for(j=0; j<5; j++){
      scanf("%d", &a[j][i]); //輸入每個同學(xué)的各科成績
      sum+=a[j][i]; //計算當(dāng)前科目的總成績
    }
    v[i]=sum/5; // 當(dāng)前科目的平均分
    sum=0;
  }
  average =(v[0]+v[1]+v[2])/3;
  printf("Math: %d\nC Languag: %d\nEnglish: %d\n", v[0], v[1], v[2]);
  printf("Total:%d\n", average);
  return 0;
}

程序中首先用了一個雙重循環(huán)鸽粉。在內(nèi)循環(huán)中依次讀入某一門課程的各個學(xué)生的成績，并把這些成績累加起來抓艳，退出內(nèi)循環(huán)后再把該累加成績除以5送入v[i]之中触机，這就是該門課程的平均成績。外循環(huán)共循環(huán)三次，分別求出三門課各自的平均成績并存放在v數(shù)組之中儡首。退出外循環(huán)之后片任，把v[0]、v[1]蔬胯、v[2]相加除以3即得到各科總平均成績对供。最后按題意輸出各個成績。

二維數(shù)組的初始化
二維數(shù)組的初始化可以按行分段賦值氛濒，也可按行連續(xù)賦值产场。例如對數(shù)組a[5][3]，按行分段賦值可寫為：int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };
按行連續(xù)賦值可寫為：int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};
這兩種賦初值的結(jié)果是完全相同的舞竿。

對于二維數(shù)組初始化賦值還有以下說明

1. 可以只對部分元素賦初值京景，未賦初值的元素自動取0值。例如：

   int a[3][3]={{1},{2},{3}};

是對每一行的第一列元素賦值骗奖，未賦值的元素取0值确徙。 賦值后各元素的值為：
1 0 0
2 0 0
3 0 0

int a [3][3]={{0,1},{0,0,2},{3}};

賦值后的元素值為：
0 1 0
0 0 2
3 0 0

2. 如對全部元素賦初值，則第一維的長度可以不給出执桌。例如：

   int a[3][3]={1,2,3,4,5,6,7,8,9};

可以寫為：

int a[][3]={1,2,3,4,5,6,7,8,9};

3. 數(shù)組是一種構(gòu)造類型的數(shù)據(jù)鄙皇。二維數(shù)組可以看作是由一維數(shù)組的嵌套而構(gòu)成的。設(shè)一維數(shù)組的每個元素都又是一個數(shù)組仰挣，就組成了二維數(shù)組伴逸。當(dāng)然，前提是各元素類型必須相同椎木。根據(jù)這樣的分析违柏，一個二維數(shù)組也可以分解為多個一維數(shù)組。C語言允許這種分解香椎。

如二維數(shù)組a[3][4]漱竖，可分解為三個一維數(shù)組，其數(shù)組名分別為：a[0]畜伐、a[1]馍惹、a[2]。

對這三個一維數(shù)組不需另作說明即可使用玛界。這三個一維數(shù)組都有4個元素万矾，例如：一維數(shù)組a[0]的元素為a[0][0], a[0][1], a[0][2], a[0][3]。必須強調(diào)的是慎框，a[0], a[1], a[2]不能當(dāng)作下標(biāo)變量使用良狈，它們是數(shù)組名，不是一個單純的下標(biāo)變量笨枯。

總的來看薪丁，C數(shù)組還是很強大的遇西。

C語言字符串

字符串（String）在處理自然語言時是不可或缺的。但是严嗜，在C語言中粱檀，沒有專門的字符串變量享郊，沒有string類型悠菜，通常就用一個字符數(shù)組來存放一個字符串荆萤。

用來存放字符的數(shù)組稱為字符數(shù)組推掸，例如：

char a[10]; //一維字符數(shù)組
char b[5][10]; //二維字符數(shù)組
char c[20]={'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a','m'}; // 給部分數(shù)組元素賦值
char d[]={'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm' }; //對全體元素賦值時可以省去長度

字符數(shù)組實際上是一系列字符的集合，也就是字符串佃扼。

C語言規(guī)定兴枯，可以將字符串直接賦值給字符數(shù)組由缆，例如：

char str[30] = {"c.biancheng.net"};
char str[30] = "c.biancheng.net"; //這種形式更加簡潔刨秆，實際開發(fā)中常用

數(shù)組第0個元素為 'c'凳谦，第1個元素為 '.'，第2個元素為 'b'衡未，后面的元素以此類推。也可以不指定數(shù)組長度家凯，例如：

char str[] = {"c.biancheng.net"};
char str[] = "c.biancheng.net"; //這種形式更加簡潔缓醋，實際開發(fā)中常用

在C語言中，字符串總是以'\0'作為串的結(jié)束符绊诲。上面的兩個字符串送粱，編譯器已經(jīng)在末尾自動添加了'\0'。'\0'是ASCII碼表中的第0個字符掂之，用NUL表示抗俄，稱為空字符。該字符既不能顯示世舰，也不是控制字符动雹，輸出該字符不會有任何效果，它在C語言中僅作為字符串的結(jié)束標(biāo)志跟压。puts 和 printf 在輸出字符串時會逐個掃描字符胰蝠，直到遇見 '\0' 才結(jié)束輸出。

需要注意的是震蒋，用字符串給字符數(shù)組賦值時由于要添加結(jié)束符 '\0'茸塞，數(shù)組的長度要比字符串的長度（字符串長度不包括 '\0'）大1。例如：

char str[] = "C program";

該數(shù)組在內(nèi)存中的實際存放情況為：

字符串長度為 9查剖，數(shù)組長度為 10钾虐。

字符串處理

C語言提供了豐富的字符串處理函數(shù)，例如字符串的輸入笋庄、輸出效扫、合并倔监、修改、比較荡短、轉(zhuǎn)換丐枉、復(fù)制、搜索等掘托，使用這些現(xiàn)成的函數(shù)可大大減輕編程的負擔(dān)瘦锹。用于輸入輸出的字符串函數(shù)，例如printf闪盔、puts弯院、scanf、gets等泪掀，使用時應(yīng)包含頭文件stdio.h听绳，使用其它字符串函數(shù)則應(yīng)包含頭文件string.h。

1）字符串操作
strcpy(p, p1) 復(fù)制字符串
strncpy(p, p1, n) 復(fù)制指定長度字符串
strcat(p, p1) 附加字符串
strncat(p, p1, n) 附加指定長度字符串
strlen(p) 取字符串長度
strcmp(p, p1) 比較字符串
strcasecmp忽略大小寫比較字符串
strncmp(p, p1, n) 比較指定長度字符串
strchr(p, c) 在字符串中查找指定字符
strrchr(p, c) 在字符串中反向查找
strstr(p, p1) 查找字符串
strpbrk(p, p1) 以目標(biāo)字符串的所有字符作為集合异赫，在當(dāng)前字符串查找該集合的任一元素
strspn(p, p1) 以目標(biāo)字符串的所有字符作為集合椅挣，在當(dāng)前字符串查找不屬于該集合的任一元素的偏移
strcspn(p, p1) 以目標(biāo)字符串的所有字符作為集合，在當(dāng)前字符串查找屬于該集合的任一元素的偏移 * 具有指定長度的字符串處理函數(shù)在已處理的字符串之后填補零結(jié)尾符

2）字符串到數(shù)值類型的轉(zhuǎn)換
strtod(p, ppend) 從字符串 p 中轉(zhuǎn)換 double 類型數(shù)值塔拳，并將后續(xù)的字符串指針存儲到 ppend 指向的 char* 類型存儲鼠证。
strtol(p, ppend, base) 從字符串 p 中轉(zhuǎn)換 long 類型整型數(shù)值，base 顯式設(shè)置轉(zhuǎn)換的整型進制靠抑，設(shè)置為 0 以根據(jù)特定格式判斷所用進制量九，0x, 0X 前綴以解釋為十六進制格式整型，0 前綴以解釋為八進制格式整型
atoi(p) 字符串轉(zhuǎn)換到 int 整型
atof(p) 字符串轉(zhuǎn)換到 double 浮點數(shù)
atol(p) 字符串轉(zhuǎn)換到 long 整型

C的字符串操作函數(shù)還算豐富颂碧，只是有些操作起來不算方便荠列。

字符串的輸出

在C語言中，輸出字符串的函數(shù)有兩個：puts()：直接輸出字符串载城，并且只能輸出字符串肌似。printf()：通過格式控制符 %s 輸出字符串。除了字符串个曙，printf() 還能輸出其他類型的數(shù)據(jù)锈嫩。

這兩個函數(shù)主要用于格式化輸出結(jié)果，請看下面的代碼：

#include <stdio.h>
int main(){
  int i;
  char str[] = "http://c.biancheng.net";
  printf("%s\n", str); //通過變量輸出
  printf("%s\n", "http://c.biancheng.net"); //直接輸出
  puts(str); //通過變量輸出
  puts("http://c.biancheng.net"); //直接輸出
  return 0;

}

運行結(jié)果：
http://c.biancheng.net
http://c.biancheng.net
http://c.biancheng.net
http://c.biancheng.net

在 printf() 函數(shù)中使用%s輸出字符串時垦搬，在變量列表中給出數(shù)組名即可呼寸，不能寫為printf("%s", str[]);。

字符串的輸入

在C語言中猴贰，輸入字符串的函數(shù)有兩個：
scanf()：通過格式控制符 %s 輸入字符串对雪。除了字符串，scanf() 還能輸入其他類型的數(shù)據(jù)米绕。
gets()：直接輸入字符串瑟捣，并且只能輸入字符串馋艺。

1. 使用 scanf() 讀取字符串
   請先看下面的例子：

   include <stdio.h>

   int main(){
   char str1[30], str2[30];
   printf("Input str1: ");
   scanf("%s", str1);
   printf("Input str2: ");
   scanf("%s", str2);
   printf("str1: %s\nstr2: %s\n", str1, str2);
   return 0;
   }

運行結(jié)果：
Input str1: c.biancheng.net↙
Input str2: Java Python C-Sharp↙
str1: c.biancheng.net
str2: Java

由于字符數(shù)組長度為30，因此輸入的字符串長度必須小于30迈套，以留出一個字節(jié)用于存放字符串結(jié)束標(biāo)志\0捐祠。對程序的說明：① 我們本來希望將 "Java Python C-Sharp" 賦值給 str2，但是 scanf() 只讀取到 "Java"桑李，這是因為 scanf() 讀取到空格時就認為字符串輸入結(jié)束了踱蛀，不會繼續(xù)讀取了。

② 在《從鍵盤輸入數(shù)據(jù)》中講到贵白，scanf 的各個變量前面要加取地址符&
率拒，用以獲得變量的地址，例如：

int a, b;
scanf("%d %d", &a, &b);

但是在本節(jié)的示例中禁荒，將字符串讀入字符數(shù)組卻沒有使用&
猬膨，例如：

char str1[20], str2[20], str3[20], str4[20];
scanf("%s %s %s %s",str1, str2, str3, str4);

這是因為C語言規(guī)定，數(shù)組名就代表了該數(shù)組的地址呛伴。整個數(shù)組是一塊連續(xù)的內(nèi)存單元勃痴，如有字符數(shù)組char c[10]，在內(nèi)存可表示為：

C語言還規(guī)定热康，數(shù)組名所代表的地址為第0個元素的地址召耘，例如char c[10];，c
就代表c[0]的地址褐隆。第0個元素的地址就是數(shù)組的起始地址，稱為首地址剖踊。也就是說庶弃，數(shù)組名表示數(shù)組的首地址。設(shè)數(shù)組c的首地址為0X2000德澈，也即c[0]地址為0X2000歇攻，則數(shù)組名c就代表這個地址。因為c已經(jīng)表示地址梆造，所以在c前面不能再加取地址符&缴守，例如寫作scanf("%s",&c);是錯誤的。

有了首地址镇辉，有了字符串結(jié)束符'\0'屡穗，就可以在內(nèi)存中完整定位一個字符串了。例如：

printf("%s", c);

printf 函數(shù)會根據(jù)數(shù)組名找到c的首地址忽肛，然后逐個輸出數(shù)組中各個字符直到遇到 '\0' 為止村砂。int、float屹逛、char 類型的變量表示數(shù)據(jù)本身础废，數(shù)據(jù)就保存在變量中汛骂；而數(shù)組名表示的是數(shù)組的首地址，數(shù)組保存在其他內(nèi)存單元评腺，數(shù)組名保存的是這塊內(nèi)存的首地址帘瞭。

2. 使用 gets() 讀取字符串
   gets 是 get string 的縮寫，意思是獲取用戶從鍵盤輸入的字符串蒿讥，語法格式為：gets(arrayName);
   arrayName 為字符數(shù)組蝶念。從鍵盤獲得的字符串，將保存在 arrayName 中诈悍。請看下面的例子：

   include <stdio.h>

   int main(){
   char str1[30], str2[30];
   printf("Input str1: ");
   gets(str1);
   printf("Input str2: ");
   gets(str2);
   printf("str1: %s\nstr2: %s\n", str1, str2);

   return 0;
   }

運行結(jié)果：
Input str1: Java Python C-Sharp↙
Input str2: http://c.biancheng.net↙
str1: Java Python C-Sharp
str2: http://c.biancheng.net

可以發(fā)現(xiàn)祸轮，當(dāng)輸入的字符串中含有空格時，輸出仍為全部字符串侥钳，這說明 gets() 函數(shù)不會把空格作為輸入結(jié)束的標(biāo)志适袜，而只把回車換行作為輸入結(jié)束的標(biāo)志，這與 scanf() 函數(shù)是不同的舷夺】嘟矗總結(jié)：如果希望讀取的字符串中不包含空格，那么使用 scanf() 函數(shù)给猾；如果希望獲取整行字符串疫萤，那么使用 gets() 函數(shù)，它能避免空格的截斷敢伸。

關(guān)于排序和查找

學(xué)完了數(shù)組扯饶，有兩個重要的實際需求，那就是排序（Sort）和查找（Search）池颈，比如：給你 10 個打亂順序的整數(shù)尾序，要能夠按照從小到大或者從大到小的順序輸出；
給定一個字符串 str1躯砰，以及一個子串 str2每币，要能夠判斷 str2 是否在 str1 中。

排序和查找的方法有很多種琢歇，C語言沒有相關(guān)內(nèi)置函數(shù)兰怠，主要使用別人的函數(shù)。這稍微弱些李茫。

數(shù)組指針

C語言異于其他語言之處在于它有指針揭保。同樣也有數(shù)組指針和指針數(shù)組。
通過指針引用數(shù)組
C語言規(guī)定：如果指針變量p已指向數(shù)組中的一個元素涌矢，則p+1指向同一數(shù)組中的下一個元素掖举。引入指針變量后，就可以用兩種方法來訪問數(shù)組元素了。這為C數(shù)組帶來了靈活多變的訪問形式塔次。當(dāng)然方篮，也容易出錯。

Java數(shù)組

在Java中励负，數(shù)組不屬于基本數(shù)據(jù)類型藕溅，而屬于引用類型。引用類型變量由類的構(gòu)造函數(shù)創(chuàng)建继榆，可以使用它們訪問所引用的對象巾表。這些變量在聲明時被指定為一個特定的類型，比如Employee略吨、Pubby等集币。變量一旦聲明后，類型就不能被改變了翠忠。
對象鞠苟、數(shù)組都是引用數(shù)據(jù)類型。所有引用類型的默認值都是null秽之。一個引用變量可以用來引用與任何與之兼容的類型当娱。
例子：Animal animal = new Animal(“giraffe”)。

Java在C的基礎(chǔ)上對數(shù)組進行了完善考榨。
首先跨细，Java明確區(qū)分了數(shù)組的聲明、創(chuàng)建和初始化河质。
在C中冀惭，我們寫int a[10]時，既是聲明了一個整型數(shù)組a,也在內(nèi)存中創(chuàng)建了它掀鹅。
而Java首先必須聲明數(shù)組變量云头，才能在程序中使用數(shù)組。下面是聲明數(shù)組變量的語法樣式：

int[] myList; // 首選的方法
int myList[]; // 仿C/C++淫半，效果相同，但不是首選方法

Java語言使用new操作符來創(chuàng)建數(shù)組匣砖，樣式如下：

mylist = new int[10];

上面的語法語句做了兩件事：
一科吭、使用 int[10]創(chuàng)建了一個數(shù)組。
二猴鲫、把新創(chuàng)建的數(shù)組的引用賦值給變量mylist对人。

數(shù)組變量的聲明和創(chuàng)建數(shù)組可以用一條語句完成，如下所示：

int[] mylist = new int[10];

另外拂共，你還可以使用如下的枚舉方式創(chuàng)建數(shù)組牺弄。
dataType[] arrayRefVar = {value0, value1, ..., valuek};
數(shù)組的元素是通過索引訪問的。數(shù)組索引從0開始宜狐，所以索引值從0到arrayRefVar.length-1势告。

示例
該實例完整地展示了如何創(chuàng)建蛇捌、初始化和操縱數(shù)組：

public class TestArray { 
  public static void main(String[] args) { 
    double[] myList = {1.9, 2.9, 3.4, 3.5}; 
   // 打印所有數(shù)組元素
    for (int i = 0; i < myList.length; i++) { 
        System.out.println(myList[i] + " "); 
    } 
    // 計算所有元素的總和
    double total = 0; 
    for (int i = 0; i < myList.length; i++) { 
        total += myList[i]; 
    } 
    System.out.println("Total is " + total); 
    // 查找最大元素 
    double max = myList[0]; 
    for (int i = 1; i < myList.length; i++) {
        if (myList[i] > max) max = myList[i]; 
    } 
    System.out.println("Max is " + max); 
  }
}

以上實例編譯運行結(jié)果如下：
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

JDK 1.5 引進了一種新的循環(huán)類型，被稱為foreach循環(huán)或者加強型循環(huán)咱台，它能在不使用下標(biāo)的情況下遍歷數(shù)組络拌。
示例
該實例用來顯示數(shù)組myList中的所有元素：

public class TestArray { 
    public static void main(String[] args) { 
        double[] myList = {1.9, 2.9, 3.4, 3.5}; 
        // 打印所有數(shù)組元素 
        for (double element: myList) { 
            System.out.println(element); 
        } 
    }
}

以上實例編譯運行結(jié)果如下：
1.9
2.9
3.4
3.5

Arrays類

作為類語言的代表，java.util.Arrays類能方便地操作數(shù)組回溺，它提供的所有方法(共4個）都是靜態(tài)的春贸。具有以下功能：
給數(shù)組賦值：通過fill方法。
對數(shù)組排序：通過sort方法,按升序遗遵。
比較數(shù)組：通過equals方法比較數(shù)組中元素值是否相等萍恕。
查找數(shù)組元素：通過binarySearch方法能對排序好的數(shù)組進行二分查找法操作。
具體說明請查看下表：
1.public static int binarySearch(Object[] a, Object key)用二分查找算法在給定數(shù)組中搜索給定值的對象(Byte,Int,double等)车要。數(shù)組在調(diào)用前必須排序好的允粤。如果查找值包含在數(shù)組中，則返回搜索鍵的索引屯蹦；否則返回 (-(插入點) - 1)维哈。

2.public static boolean equals(long[] a, long[] a2)如果兩個指定的 long 型數(shù)組彼此相等，則返回 true登澜。如果兩個數(shù)組包含相同數(shù)量的元素阔挠，并且兩個數(shù)組中的所有相應(yīng)元素對都是相等的，則認為這兩個數(shù)組是相等的脑蠕。換句話說购撼，如果兩個數(shù)組以相同順序包含相同的元素，則兩個數(shù)組是相等的谴仙。同樣的方法適用于所有的其他基本數(shù)據(jù)類型（Byte迂求，short，Int等）晃跺。

3.public static void fill(int[] a, int val)將指定的 int 值分配給指定 int 型數(shù)組指定范圍中的每個元素揩局。同樣的方法適用于所有的其他基本數(shù)據(jù)類型（Byte，short掀虎，Int等）凌盯。

4.public static void sort(Object[] a)對指定對象數(shù)組根據(jù)其元素的自然順序進行升序排列。同樣的方法適用于所有的其他基本數(shù)據(jù)類型（Byte烹玉，short驰怎，Int等）。

相比其他語言二打，Java的數(shù)組方法不算多县忌，但都是最常用的。

String類

相對于C語言沒有字符串類型（只能用字符數(shù)組），字符串類型廣泛應(yīng)用在Java編程中症杏，在Java中字符串屬于對象装获，Java提供了String類來創(chuàng)建和操作字符串。

創(chuàng)建字符串
創(chuàng)建字符串最簡單的方式如下:

String greeting = "Hello world!";

在代碼中遇到字符串常量時鸳慈，這里的值是"Hello world!"饱溢，編譯器會使用該值創(chuàng)建一個String對象。
和其它對象一樣走芋，可以使用關(guān)鍵字和構(gòu)造方法來創(chuàng)建String對象绩郎。
String類有11種構(gòu)造方法，這些方法提供不同的參數(shù)來初始化字符串翁逞，比如提供一個字符數(shù)組參數(shù):

char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.'}; 
String helloString = new String(helloArray); 

注意:String類是不可改變的肋杖，所以你一旦創(chuàng)建了String對象，那它的值就無法改變了挖函。 如果需要對字符串做很多修改状植，那么應(yīng)該選擇使用StringBuffer & StringBuilder 類。

輸出格式化字符串
我們知道輸出格式化數(shù)字可以使用printf()和format()方法怨喘。String類使用靜態(tài)方法format()返回一個String對象而不是PrintStream對象津畸。
String類的靜態(tài)方法format()能用來創(chuàng)建可復(fù)用的格式化字符串，而不僅僅是用于一次打印輸出必怜。如下所示：

System.out.printf("The value of the float variable is " + 
                          "%f, while the value of the integer " + 
                          "variable is %d, and the string " + 
                          "is %s", floatVar, intVar, stringVar);

你也可以這樣寫：

String fs;
fs = String.format("The value of the float variable is " + 
                           "%f, while the value of the integer " +
                           "variable is %d, and the string " + 
                            "is %s", floatVar, intVar, stringVar);
System.out.println(fs);

字符串的方法

Java擁有非常豐富的字符串操作方法肉拓，下面是String類支持的方法，更多詳細梳庆，參看Java API文檔:
1 char charAt(int index)
返回指定索引處的 char 值暖途。
2 int compareTo(Object o)
把這個字符串和另一個對象比較。
3 int compareTo(String anotherString)
按字典順序比較兩個字符串膏执。
4 int compareToIgnoreCase(String str)
按字典順序比較兩個字符串驻售，不考慮大小寫。
5 String concat(String str)
將指定字符串連接到此字符串的結(jié)尾更米。
6 boolean contentEquals(StringBuffer sb)
當(dāng)且僅當(dāng)字符串與指定的StringButter有相同順序的字符時候返回真欺栗。
7 static String copyValueOf(char[] data)
返回指定數(shù)組中表示該字符序列的 String。
8 static String copyValueOf(char[] data, int offset, int count)
返回指定數(shù)組中表示該字符序列的 String征峦。
9 boolean endsWith(String suffix)
測試此字符串是否以指定的后綴結(jié)束纸巷。
10 boolean equals(Object anObject)
將此字符串與指定的對象比較。
11 boolean equalsIgnoreCase(String anotherString)
將此 String 與另一個 String 比較眶痰，不考慮大小寫。
12 byte[] getBytes()
使用平臺的默認字符集將此 String 編碼為 byte 序列梯啤，并將結(jié)果存儲到一個新的 byte 數(shù)組中竖伯。
13 byte[] getBytes(String charsetName)
使用指定的字符集將此 String 編碼為 byte 序列，并將結(jié)果存儲到一個新的 byte 數(shù)組中。
14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
將字符從此字符串復(fù)制到目標(biāo)字符數(shù)組七婴。
15 int hashCode()
返回此字符串的哈希碼祟偷。
16 int indexOf(int ch)
返回指定字符在此字符串中第一次出現(xiàn)處的索引。
17 int indexOf(int ch, int fromIndex)
返回在此字符串中第一次出現(xiàn)指定字符處的索引打厘，從指定的索引開始搜索修肠。
18 int indexOf(String str)
返回指定子字符串在此字符串中第一次出現(xiàn)處的索引。
19 int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出現(xiàn)處的索引户盯，從指定的索引開始嵌施。
20 String intern()
返回字符串對象的規(guī)范化表示形式。
21 int lastIndexOf(int ch)
返回指定字符在此字符串中最后一次出現(xiàn)處的索引莽鸭。
22 int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出現(xiàn)處的索引吗伤，從指定的索引處開始進行反向搜索。
23 int lastIndexOf(String str)
返回指定子字符串在此字符串中最右邊出現(xiàn)處的索引硫眨。
24 int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出現(xiàn)處的索引足淆，從指定的索引開始反向搜索。
25 int length()
返回此字符串的長度礁阁。
26 boolean matches(String regex)
告知此字符串是否匹配給定的正則表達式巧号。
27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
測試兩個字符串區(qū)域是否相等。
28 boolean regionMatches(int toffset, String other, int ooffset, int len)
測試兩個字符串區(qū)域是否相等姥闭。
29 String replace(char oldChar, char newChar)
返回一個新的字符串丹鸿，它是通過用 newChar 替換此字符串中出現(xiàn)的所有 oldChar 得到的。
30 String replaceAll(String regex, String replacement
使用給定的 replacement 替換此字符串所有匹配給定的正則表達式的子字符串泣栈。
31 String replaceFirst(String regex, String replacement)
使用給定的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串卜高。
32 String[] split(String regex)
根據(jù)給定正則表達式的匹配拆分此字符串。
33 String[] split(String regex, int limit)
根據(jù)匹配給定的正則表達式來拆分此字符串南片。
34 boolean startsWith(String prefix)
測試此字符串是否以指定的前綴開始掺涛。
35 boolean startsWith(String prefix, int toffset)
測試此字符串從指定索引開始的子字符串是否以指定前綴開始。
36 CharSequence subSequence(int beginIndex, int endIndex)
返回一個新的字符序列疼进，它是此序列的一個子序列薪缆。
37 String substring(int beginIndex)
返回一個新的字符串，它是此字符串的一個子字符串伞广。
38 String substring(int beginIndex, int endIndex)
返回一個新字符串拣帽，它是此字符串的一個子字符串。
39 char[] toCharArray()
將此字符串轉(zhuǎn)換為一個新的字符數(shù)組嚼锄。
40 String toLowerCase()
使用默認語言環(huán)境的規(guī)則將此 String 中的所有字符都轉(zhuǎn)換為小寫减拭。
41 String toLowerCase(Locale locale)
使用給定 Locale 的規(guī)則將此 String 中的所有字符都轉(zhuǎn)換為小寫。
42 String toString()
返回此對象本身（它已經(jīng)是一個字符串Ｇ蟆）拧粪。
43 String toUpperCase()
使用默認語言環(huán)境的規(guī)則將此 String 中的所有字符都轉(zhuǎn)換為大寫修陡。
44 String toUpperCase(Locale locale)
使用給定 Locale 的規(guī)則將此 String 中的所有字符都轉(zhuǎn)換為大寫。
45 String trim()
返回字符串的副本可霎，忽略前導(dǎo)空白和尾部空白魄鸦。
46 static String valueOf(primitive data type x)
返回給定data type類型x參數(shù)的字符串表示形式。

Java StringBuffer和StringBuilder類

如上所述癣朗，Java中的String類適用于常量拾因，當(dāng)對字符串進行修改的時候，需要使用StringBuffer和StringBuilder類旷余。
和String類不同的是绢记，StringBuffer和StringBuilder類的對象能夠被多次的修改，并且不產(chǎn)生新的未使用對象荣暮。
StringBuilder類在Java 5中被提出庭惜，它和StringBuffer之間的最大不同在于StringBuilder的方法不是線程安全的（不能同步訪問）。
由于StringBuilder相較于StringBuffer有速度優(yōu)勢，所以多數(shù)情況下建議使用StringBuilder類。然而在應(yīng)用程序要求線程安全的情況下初婆，則必須使用StringBuffer類。
實例

public class Test{
     public static void main(String args[]){ 
            StringBuffer sBuffer = new StringBuffer(" test");
            sBuffer.append(" String Buffer"); 
            System.out.println(sBuffer); 
    }
}

以上實例編譯運行結(jié)果如下：
test String Buffer

StringBuffer 方法
以下是StringBuffer類支持的主要方法：
序號 方法描述
1.public StringBuffer append(String s)將指定的字符串追加到此字符序列骏啰。

2.public StringBuffer reverse() 將此字符序列用其反轉(zhuǎn)形式取代。

3.public delete(int start, int end)移除此序列的子字符串中的字符抽高。

4.public insert(int offset, int i)將 int
參數(shù)的字符串表示形式插入此序列中判耕。

5.replace(int start, int end, String str)使用給定 String
中的字符替換此序列的子字符串中的字符。

其他方法和String類的方法類似翘骂。

JavaScript 數(shù)組

在程序語言中數(shù)組的重要性不言而喻壁熄，JavaScript中數(shù)組也是最常使用的對象之一（數(shù)組是對象），數(shù)組是值的有序集合碳竟，由于弱類型的原因草丧，JavaScript中數(shù)組十分靈活、強大莹桅，不像是Java等強類型高級語言數(shù)組只能存放同一類型或其子類型元素昌执，JavaScript在同一個數(shù)組中可以存放多種類型的元素，而且是長度也是可以動態(tài)調(diào)整的诈泼，可以隨著數(shù)據(jù)增加或減少自動對數(shù)組長度做更改懂拾。這就使JavaScript數(shù)組異常靈活和強大。

創(chuàng)建數(shù)組

在JavaScript2種方式創(chuàng)建數(shù)組——構(gòu)造函數(shù)和字面量

構(gòu)造函數(shù)
1.無參構(gòu)造函數(shù)铐达，創(chuàng)建一空數(shù)組

var a1=new Array();

2.一個數(shù)字參數(shù)構(gòu)造函數(shù)岖赋，指定數(shù)組長度（由于數(shù)組長度可以動態(tài)調(diào)整，作用并不大）瓮孙，創(chuàng)建指定長度的數(shù)組

var a2=new Array(5);

3.帶有初始化數(shù)據(jù)的構(gòu)造函數(shù)唐断，創(chuàng)建數(shù)組并初始化參數(shù)數(shù)據(jù)

var a3=new Array(4,'hello',new Date());

字面量
1.使用方括號汁汗，創(chuàng)建空數(shù)組，等同于調(diào)用無參構(gòu)造函數(shù)

var a4=[];

2.使用中括號栗涂，并傳入初始化數(shù)據(jù)，等同于調(diào)用調(diào)用帶有初始化數(shù)據(jù)的構(gòu)造函數(shù)

var a5=[10];

注意點
1.在使用構(gòu)造函數(shù)創(chuàng)建數(shù)組時如果傳入一個數(shù)字參數(shù)祈争，則會創(chuàng)建一個長度為參數(shù)的數(shù)組斤程，如果傳入多個，則創(chuàng)建一個數(shù)組菩混，參數(shù)作為初始化數(shù)據(jù)加到數(shù)組中

var a1=new Array(5); 
console.log(a1.length);//5 
console.log(a1); //[] ,數(shù)組是空的 
var a2=new Array(5,6); 
console.log(a2.length);//2 
console.log(a2); //[5,6]

但是使用字面量方式忿墅，無論傳入幾個參數(shù)，都會把參數(shù)當(dāng)作初始化內(nèi)容

var a1=[5];
console.log(a1.length);//1
console.log(a1); //[5]

var a2=[5,6];
console.log(a2.length);//2
console.log(a2); //[5,6]

數(shù)組的索引與長度

數(shù)組的值可以通過自然數(shù)索引訪問進行讀寫操作沮峡，下標(biāo)也可以是一個得出非負整數(shù)的變量或表達式

var a1=[1,2,3,4];
console.log(a1[0]); //1
var i=1;
console.log(a1[i]); //2
console.log(a1[++i]); //3

數(shù)組的索引可以不是連續(xù)的疚脐，訪問index不存在的元素的時候返回undefined

var a=new Array(1,2,3);
        a[100]=100;
        console.log(a.length); //101
        console.log(a[3]); //undefined
        console.log(a[99]); //undefined
        console.log(a[100]); 100

上面的例子中，雖然直接對a[100]賦值不會影響a[4]或a[99],但數(shù)組的長度卻受到影響邢疙，數(shù)組length屬性等于數(shù)組中最大的index+1棍弄，我們知道數(shù)組的length屬性同樣是個可寫的屬性，當(dāng)強制把數(shù)組的length屬性值設(shè)置為小于等于最大index值時疟游，數(shù)組會自動刪除indexd大于等于length的數(shù)據(jù)呼畸，在剛才代碼中追加幾句

a.length=2 console.log(a);//[1,2]

這時候會發(fā)現(xiàn)a[2]和a[100]被自動刪除了，同理颁虐，如果把length設(shè)置為大于最大index+1的值的時候蛮原，數(shù)組也會自動擴張，但是不會為數(shù)組添加新元素另绩，只是在尾部追加空空間

a.length=5; 
console.log(a); //[1,2] //后面沒有3個undefined

修改已有數(shù)組中的值
如需修改已有數(shù)組中的值儒陨，只要向指定索引（下標(biāo)號）添加一個新值即可：

var mycars=new Array("Saab","Volvo","BMW")
mycars[0]="Opel";
document.write(mycars[0]);

將輸出：Opel

元素添加/刪除
上面例子已經(jīng)用到向數(shù)組內(nèi)添加元素方法，直接使用索引就可以（index沒必要連續(xù)）

var a=new Array(1,2,3); 
a[3]=4; 
console.log(a);//[1, 2, 3, 4]

前面提到數(shù)組也是對象笋籽，索引只是特殊的屬性蹦漠，所以我們可以使用刪除對象屬性的方法,使用delete 刪除數(shù)組元素

delete a[2];
console.log(a[2]); //undefined

這樣和直接把a[2]賦值為undefined類似，不會改變數(shù)組長度干签，也不會改變其他數(shù)據(jù)的index和value對應(yīng)關(guān)系

數(shù)組的屬性##

JavaScript的數(shù)組是對象津辩，所以有屬性。共三大屬性：
[constructor] 返回對創(chuàng)建此對象的數(shù)組函數(shù)的引用容劳。
例子 1
在本例中喘沿，我們將展示如何使用 constructor 屬性：

<script type="text/javascript">
    var test=new Array();
    if (test.constructor==Array){
        document.write("This is an Array");
    }if (test.constructor==Boolean){
        document.write("This is a Boolean");
    }if (test.constructor==Date){
        document.write("This is a Date");
    }if (test.constructor==String){
        document.write("This is a String");
    }
</script>

輸出：
This is an Array

例子 2
在本例中，我們將展示如何使用 constructor 屬性：

<script type="text/javascript">
function employee(name,job,born{
    this.name=name;
    this.job=job;
    this.born=born;
}
var bill=new employee("Bill Gates","Engineer",1985)竭贩；
document.write(bill.constructor);
</script>

輸出：
function employee(name,job,born) { this.name=name; this.job=job; this.born=born; }

[length]設(shè)置或返回數(shù)組中元素的數(shù)目蚜印。
語法
arrayObject.length
說明
length不是方法而是屬性。數(shù)組的 length 屬性總是比數(shù)組中定義的最后一個元素的下標(biāo)大 1留量。對于那些具有連續(xù)元素窄赋，而且以元素 0 開始的常規(guī)數(shù)組而言哟冬，屬性 length 聲明了數(shù)組中的元素的個數(shù)。
數(shù)組的 length 屬性在用構(gòu)造函數(shù) Array() 創(chuàng)建數(shù)組時被初始化忆绰。給數(shù)組添加新元素時浩峡，如果必要，將更新 length 的值错敢。
設(shè)置 length 屬性可改變數(shù)組的大小翰灾。如果設(shè)置的值比其當(dāng)前值小，數(shù)組將被截斷稚茅，其尾部的元素將丟失纸淮。如果設(shè)置的值比它的當(dāng)前值大，數(shù)組將增大亚享，新的元素被添加到數(shù)組的尾部咽块，它們的值為 undefined。
在本例中欺税，我們將展示如何使用 length 屬性返回并設(shè)置數(shù)組的長度：

var arr = new Array(3)
arr[0] = "John"
arr[1] = "Andy"
arr[2] = "Wendy"
document.write("Original length: " + arr.length)
document.write("<br />")
arr.length=5
document.write("New length: " + arr.length)

輸出：
Original length: 3
New length: 5

[prototype]使您有能力向?qū)ο筇砑訉傩院头椒ā?br> 語法
object.prototype.name=value
實例
在本例中侈沪，我們將展示如何使用 prototype 屬性來向?qū)ο筇砑訉傩裕?/p>

function employee(name,job,born){
    this.name=name;
    this.job=job;
    this.born=born;
}
var bill=new employee("Bill Gates","Engineer",1985);
employee.prototype.salary=null;
bill.salary=20000;
document.write(bill.salary);

輸出：
20000

Array 對象方法##

JavaScript的數(shù)組方法也很多。
[concat()]連接兩個或更多的數(shù)組魄衅，并返回結(jié)果峭竣。
[join()]把數(shù)組的所有元素放入一個字符串。元素通過指定的分隔符進行分隔晃虫。
[pop()]刪除并返回數(shù)組的最后一個元素
[push()]向數(shù)組的末尾添加一個或更多元素皆撩，并返回新的長度。
[reverse()]顛倒數(shù)組中元素的順序哲银。
[shift()]刪除并返回數(shù)組的第一個元素
[slice()]從某個已有的數(shù)組返回選定的元素
[sort()]對數(shù)組的元素進行排序
[splice()]刪除元素扛吞，并向數(shù)組添加新元素。
[toSource()]返回該對象的源代碼荆责。
[toString()]把數(shù)組轉(zhuǎn)換為字符串滥比，并返回結(jié)果。
[toLocaleString()]把數(shù)組轉(zhuǎn)換為本地數(shù)組做院，并返回結(jié)果盲泛。
[unshift()]向數(shù)組的開頭添加一個或更多元素，并返回新的長度键耕。
[valueOf()]返回數(shù)組對象的原始值

了解了這些看看數(shù)組真的很了不得啊寺滚，即強大有靈活，但是在遍歷元素屈雄，及獲取元素位置等也有一定的不便村视，這些在ECMAScript中已經(jīng)得到解決。

ES6對數(shù)組的擴展##

Array.from()
可以將各種值酒奶、對象轉(zhuǎn)為真正的數(shù)組蚁孔，并且還提供map功能奶赔。這實際上意味著，只要有一個原始的數(shù)據(jù)結(jié)構(gòu)杠氢，你就可以先對它的值進行處理站刑，然后轉(zhuǎn)成規(guī)范的數(shù)組結(jié)構(gòu)，進而就可以使用數(shù)量眾多的數(shù)組方法鼻百。

Array.from({ length: 2 }, () => 'jack')// ['jack', 'jack']

上面代碼中笛钝，Array.from的第一個參數(shù)創(chuàng)建了一個長度為2的數(shù)組，第二個參數(shù)將其每個值都賦為“jack”愕宋。這種特性可以讓該方法的用法變得非常靈活。

Array.from方法用于將兩類對象轉(zhuǎn)為真正的數(shù)組：類似數(shù)組的對象（array-like object）和可遍歷（iterable）的對象（包括ES6新增的數(shù)據(jù)結(jié)構(gòu)Set和Map）结榄。
下面是一個類似數(shù)組的對象中贝，Array.from
將它轉(zhuǎn)為真正的數(shù)組。

let arrayLike = { 
    '0': 'a', 
    '1': 'b',
    '2': 'c', 
    length: 3
};
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

實際應(yīng)用中臼朗，常見的類似數(shù)組的對象是DOM操作返回的NodeList集合邻寿，以及函數(shù)內(nèi)部的arguments對象。Array.from都可以將它們轉(zhuǎn)為真正的數(shù)組视哑。

Array.from()的另一個應(yīng)用是绣否，將字符串轉(zhuǎn)為數(shù)組，然后返回字符串的長度挡毅。因為它能正確處理各種Unicode字符蒜撮，可以避免JavaScript將大于\uFFFF的Unicode字符，算作兩個字符的bug跪呈。

Array.from('hello')// ['h', 'e', 'l', 'l', 'o']

Array.of()
Array.of方法用于將一組值段磨，轉(zhuǎn)換為數(shù)組。

Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1

這個方法的主要目的耗绿，是彌補數(shù)組構(gòu)造函數(shù)Array()
的不足苹支。因為參數(shù)個數(shù)的不同，會導(dǎo)致Array()
的行為有差異误阻。

Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]

上面代碼中债蜜，Array方法沒有參數(shù)、一個參數(shù)究反、三個參數(shù)時寻定，返回結(jié)果都不一樣。只有當(dāng)參數(shù)個數(shù)不少于2個時奴紧，Array()才會返回由參數(shù)組成的新數(shù)組特姐。參數(shù)個數(shù)只有一個時，實際上是指定數(shù)組的長度黍氮。
Array.of基本上可以用來替代Array()或new Array()唐含，并且不存在由于參數(shù)不同而導(dǎo)致的重載浅浮。它的行為非常統(tǒng)一。

Array.of() // []
Array.of(undefined) // [undefined]
Array.of(1) // [1]
Array.of(1, 2) // [1, 2]

Array.of總是返回參數(shù)值組成的數(shù)組捷枯。如果沒有參數(shù)滚秩，就返回一個空數(shù)組。

新方法
數(shù)組實例的copyWithin()淮捆、find()和findIndex()郁油、fill()、entries()攀痊，keys()和values()]桐腌、includes()都是新的方法。

ES6提供三個新的方法——entries()苟径，keys()和values()——用于遍歷數(shù)組案站。它們都返回一個遍歷器對象（詳見《Iterator》一章），可以用for...of循環(huán)進行遍歷棘街，唯一的區(qū)別是keys()是對鍵名的遍歷蟆盐、values()是對鍵值的遍歷，entries()
是對鍵值對的遍歷遭殉。這個異常強大石挂。

includes()則是完美的確定數(shù)組是否包含給定的值的方法。find方法险污，用于找出第一個符合條件的數(shù)組成員痹愚。

數(shù)組空位
數(shù)組的空位指，數(shù)組的某一個位置沒有任何值蛔糯。比如里伯，Array
構(gòu)造函數(shù)返回的數(shù)組都是空位。

Array(3) // [, , ,]

上面代碼中渤闷，Array(3)返回一個具有3個空位的數(shù)組疾瓮。注意，空位不是undefined
飒箭，一個位置的值等于undefined狼电，依然是有值的∠阴澹空位是沒有任何值肩碟，in運算符可以說明這一點。

ES6則是明確將空位轉(zhuǎn)為undefined凸椿。
Array.from方法會將數(shù)組的空位削祈，轉(zhuǎn)為undefined，也就是說，這個方法不會忽略空位髓抑。

Array.from(['a',,'b'])// [ "a", undefined, "b" ]

由于空位的處理規(guī)則非常不統(tǒng)一咙崎，所以建議避免出現(xiàn)空位。

JavaScript字符串##

JavaScript有字符串對象吨拍，不但非常靈活褪猛，而且與正則表達式緊密結(jié)合，十分強大羹饰。
String 對象用于處理文本（字符串）伊滋。
創(chuàng)建 String 對象的語法：
new String(s);
String(s);
參數(shù) s 是要存儲在 String 對象中或轉(zhuǎn)換成原始字符串的值。
返回值
當(dāng) String() 和運算符 new 一起作為構(gòu)造函數(shù)使用時队秩，它返回一個新創(chuàng)建的 String 對象笑旺，存放的是字符串 s 或 s 的字符串表示。
當(dāng)不用 new 運算符調(diào)用 String() 時馍资，它只把 s 轉(zhuǎn)換成原始的字符串燥撞，并返回轉(zhuǎn)換后的值。
實際中一般使用如下的簡單初始化法創(chuàng)建字符串：

var txt="Hello world!";

這等同于：

var txt = new Strings（"Hello world!");

像數(shù)組對象一樣迷帜，String 對象也有三大屬性：
constructor 對創(chuàng)建該對象的函數(shù)的引用
length 字符串的長度
prototype 允許您向?qū)ο筇砑訉傩院头椒?/p>

最常用的是length屬性：

document.write(txt.length)

需要注意的是，JavaScript 的字符串是不可變的（immutable）色洞，String 類定義的方法都不能改變字符串的內(nèi)容戏锹。像 String.toUpperCase() 這樣的方法，返回的是全新的字符串火诸，而不是修改原始字符串锦针。

字符串方法###

String 類定義了大量操作字符串的方法，例如從字符串中提取字符或子串置蜀，或者檢索字符或子串奈搜，甚至有很多關(guān)于現(xiàn)實樣式的。

[anchor()]創(chuàng)建 HTML 錨盯荤。

[big()]用大號字體顯示字符串馋吗。

[blink()]顯示閃動字符串。

[bold()]使用粗體顯示字符串秋秤。

[charAt()]返回在指定位置的字符宏粤。

[charCodeAt()]返回在指定的位置的字符的 Unicode 編碼。

[concat()]連接字符串灼卢。

[fixed()]以打字機文本顯示字符串绍哎。

[fontcolor()]使用指定的顏色來顯示字符串。

[fontsize()]使用指定的尺寸來顯示字符串鞋真。

[fromCharCode()]從字符編碼創(chuàng)建一個字符串崇堰。

[indexOf()]檢索字符串。

[italics()]使用斜體顯示字符串。

[lastIndexOf()]從后向前搜索字符串海诲。

[link()]將字符串顯示為鏈接繁莹。

[localeCompare()]用本地特定的順序來比較兩個字符串。

[match()]找到一個或多個正則表達式的匹配饿肺。

[replace()]替換與正則表達式匹配的子串蒋困。

[search()]檢索與正則表達式相匹配的值。

[slice()]提取字符串的片斷敬辣，并在新的字符串中返回被提取的部分雪标。

[small()]使用小字號來顯示字符串。

[split()]把字符串分割為字符串?dāng)?shù)組溉跃。

[strike()]使用刪除線來顯示字符串村刨。

[sub()]把字符串顯示為下標(biāo)。

[substr()]從起始索引號提取字符串中指定數(shù)目的字符撰茎。

[substring()]提取字符串中兩個指定的索引號之間的字符。

[sup()]把字符串顯示為上標(biāo)龄糊。

[toLocaleLowerCase()]把字符串轉(zhuǎn)換為小寫逆粹。

[toLocaleUpperCase()]把字符串轉(zhuǎn)換為大寫。

[toLowerCase()]把字符串轉(zhuǎn)換為小寫炫惩。

[toUpperCase()]把字符串轉(zhuǎn)換為大寫僻弹。

toSource()代表對象的源代碼。

[toString()]返回字符串他嚷。

[valueOf()]返回某個字符串對象的原始值蹋绽。

ES6對字符串的加強###

本來JavaScript的字符串功能已經(jīng)很強大了，ES6又做了很多補充筋蓖。
首先卸耘，對Unicode的支持大大增強，且提供了codePointAt
方法粘咖，能夠正確處理4個字節(jié)儲存的字符蚣抗。

ES6為字符串添加了遍歷器接口，使得字符串可以被for...of
循環(huán)遍歷瓮下。

for (let codePoint of 'foo') { 
    console.log(codePoint)
}// "f"http:// "o"http:// "o"

傳統(tǒng)上忠聚，JavaScript只有indexOf方法，可以用來確定一個字符串是否包含在另一個字符串中唱捣。ES6又提供了三種新方法两蟀。
includes()：返回布爾值，表示是否找到了參數(shù)字符串震缭。
startsWith()：返回布爾值赂毯，表示參數(shù)字符串是否在源字符串的頭部。
endsWith()：返回布爾值，表示參數(shù)字符串是否在源字符串的尾部党涕。

var s = 'Hello world!';
s.startsWith('Hello') // true
s.endsWith('!') // true
s.includes('o') // true

repeat方法返回一個新字符串烦感，表示將原字符串重復(fù)n次。

'x'.repeat(3) // "xxx"
'hello'.repeat(2) // "hellohello"

ES7推出了字符串補全長度的功能膛堤。如果某個字符串不夠指定長度手趣，會在頭部或尾部補全。padStart用于頭部補全肥荔，padEnd用于尾部補全绿渣。

最強悍的地方，是模板的增強：
模板字符串（template string）是增強版的字符串燕耿，用反引號（`）標(biāo)識中符。它可以當(dāng)作普通字符串使用，也可以用來定義多行字符串誉帅，或者在字符串中嵌入變量淀散。

// 字符串中嵌入變量
var name = "Bob",
time = "today";
Hello ${name}, how are you ${time}?

模板字符串中嵌入變量，需要將變量名寫在{user.name} is not authorized to do ${action}.`); }}

大括號內(nèi)部可以放入任意的JavaScript表達式档插，可以進行運算，以及引用對象屬性亚再。

var x = 1;
var y = 2;
`${x} + ${y} = ${x + y}`// "1 + 2 = 3"

模板字符串之中還能調(diào)用函數(shù)郭膛。

function fn() { 
    return "Hello World";
}
`foo ${fn()} bar`// foo Hello World bar

模板字符串的功能，不僅僅是上面這些针余。它可以緊跟在一個函數(shù)名后面，該函數(shù)將被調(diào)用來處理這個模板字符串凄诞。這被稱為“標(biāo)簽?zāi)０濉惫δ埽╰agged template）圆雁。
標(biāo)簽?zāi)０迤鋵嵅皇悄０澹呛瘮?shù)調(diào)用的一種特殊形式帆谍∥毙啵“標(biāo)簽”指的就是函數(shù)，緊跟在后面的模板字符串就是它的參數(shù)汛蝙。

var a = 5;
var b = 10;
tag`Hello ${ a + b } world ${ a * b }`;

上面代碼中烈涮，模板字符串前面有一個標(biāo)識名tag，它是一個函數(shù)窖剑。整個表達式的返回值坚洽，就是tag函數(shù)處理模板字符串后的返回值。

“標(biāo)簽?zāi)０濉钡囊粋€重要應(yīng)用西土，就是過濾HTML字符串讶舰，防止用戶輸入惡意內(nèi)容。
標(biāo)簽?zāi)０宓牧硪粋€應(yīng)用，就是多語言轉(zhuǎn)換（國際化處理）跳昼。

i18n`Welcome to ${siteName}, 
you are visitor number ${visitorNumber}!`// "歡迎訪問xxx般甲，您是第xxxx位訪問者！"

模板字符串本身并不能取代Mustache之類的模板庫鹅颊，因為沒有條件判斷和循環(huán)處理功能敷存，但是通過標(biāo)簽函數(shù)，你可以自己添加這些功能堪伍。
// 下面的hashTemplate函數(shù)// 是一個自定義的模板處理函數(shù)

var libraryHtml = hashTemplate
` <ul> #for book in ${myBooks} 
      <li><i>#{book.title}</i> by #{book.author}</li> #end
  </ul>`;

除此之外锚烦，你甚至可以使用標(biāo)簽?zāi)０澹贘avaScript語言之中嵌入其他語言杠娱。

是不是無比強大了挽牢？

Swift數(shù)組

在Swift 語言中，數(shù)組是集合類型（Collection）的一種摊求，用來存儲復(fù)合數(shù)據(jù)禽拔。數(shù)組（Arrays）是有序數(shù)據(jù)的集。集合（Sets）是無序無重復(fù)數(shù)據(jù)的集室叉。字典（Dictionaries）是無序的鍵值對的集睹栖。

Swift 語言中的Arrays、Sets和Dictionaries中存儲的數(shù)據(jù)值類型必須明確（統(tǒng)一）茧痕。這意味著我們不能把不正確的數(shù)據(jù)類型插入其中（JavaScript在同一個數(shù)組中可以存放多種類型的元素）野来，同時這也說明Swift更注重語言安全和效率。

數(shù)組使用有序列表存儲同一類型的多個值踪旷。相同的值可以多次出現(xiàn)在一個數(shù)組的不同位置中曼氛。

數(shù)組的創(chuàng)建##

Swift中可以使用構(gòu)造函數(shù)和字面量兩種方法創(chuàng)建數(shù)組。
創(chuàng)建一個空數(shù)組
我們可以使用構(gòu)造語法來創(chuàng)建一個由特定數(shù)據(jù)類型構(gòu)成的空數(shù)組：

var someInts = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// 打印 "someInts is of type [Int] with 0 items."

注意令野，通過構(gòu)造函數(shù)的類型舀患，someInts的值類型被推斷為[Int]。
或者气破，如果代碼上下文中已經(jīng)提供了類型信息聊浅，例如一個函數(shù)參數(shù)或者一個已經(jīng)定義好類型的常量或者變量，我們可以使用空數(shù)組語句創(chuàng)建一個空數(shù)組现使，它的寫法很簡單：[]（一對空方括號）：

someInts = []   

可以用append方法來簡單地給數(shù)組添加元素

someInts.append(3)
// someInts 現(xiàn)在包含一個 Int 值 

創(chuàng)建一個帶有默認值的數(shù)組
Swift 中的Array類型還提供一個可以創(chuàng)建特定大小并且所有數(shù)據(jù)都被默認的構(gòu)造方法低匙。我們可以把準(zhǔn)備加入新數(shù)組的數(shù)據(jù)項數(shù)量（count）和適當(dāng)類型的初始值（repeatedValue）傳入數(shù)組構(gòu)造函數(shù)：

var threeDoubles = [Double](count: 3, repeatedValue:0.0)

// threeDoubles 是一種 [Double] 數(shù)組，等價于 [0.0, 0.0, 0.0]

這種創(chuàng)建大量相同值的方法別的語言還真沒有碳锈。更強的是顽冶，還可以用類似字符串的“+”法來拼接兩個數(shù)組創(chuàng)建新數(shù)組。我們可以使用加法操作符（+）來組合兩種已存在的相同類型數(shù)組售碳。新數(shù)組的數(shù)據(jù)類型會被從兩個數(shù)組的數(shù)據(jù)類型中推斷出來：

var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
// anotherThreeDoubles 被推斷為 [Double]渗稍，等價于 [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推斷為 [Double]佩迟，等價于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

用字面量構(gòu)造數(shù)組

我們可以使用字面量來進行數(shù)組構(gòu)造，這是一種用一個或者多個數(shù)值構(gòu)造數(shù)組的簡單方法竿屹。字面量是一系列由逗號分割并由方括號包含的數(shù)值：

[value 1, value 2, value 3]报强。

下面這個例子創(chuàng)建了一個叫做shoppingList并且存儲String的數(shù)組：

var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 已經(jīng)被構(gòu)造并且擁有兩個初始項。

shoppingList變量被聲明為“字符串值類型的數(shù)組“拱燃，記作[String]秉溉。 因為這個數(shù)組被規(guī)定只有String一種數(shù)據(jù)結(jié)構(gòu)，所以只有String類型可以在其中被存取碗誉。 在這里召嘶，shoppinglist數(shù)組由兩個String值（"Eggs" 和"Milk"）構(gòu)造，并且由字面量定義哮缺。

在這個例子中弄跌，字面量僅僅包含兩個String值。匹配了該數(shù)組的變量聲明（只能包含String的數(shù)組）尝苇，所以這個字面量的分配過程可以作為用兩個初始項來構(gòu)造shoppinglist的一種方式铛只。

由于 Swift 的類型推斷機制，當(dāng)我們用字面量構(gòu)造只擁有相同類型值數(shù)組的時候糠溜，我們不必把數(shù)組的類型定義清楚淳玩。 shoppinglist的構(gòu)造也可以這樣寫：

var shoppingList = ["Eggs", "Milk"]

因為所有字面量中的值都是相同的類型，Swift 可以推斷出[String]是shoppinglist中變量的正確類型非竿。

數(shù)組的下標(biāo)##

Swift數(shù)組同樣可以通過下標(biāo)來訪問和修改蜕着。
可以直接使用下標(biāo)語法來獲取數(shù)組中的數(shù)據(jù)項，把我們需要的數(shù)據(jù)項的索引值放在直接放在數(shù)組名稱的方括號中：

var firstItem = shoppingList[0]
// 第一項是 "Eggs"

注意：
第一項在數(shù)組中的索引值是0而不是1红柱。 Swift 中的數(shù)組索引總是從零開始承匣。
我們也可以用下標(biāo)來改變某個已有索引值對應(yīng)的數(shù)據(jù)值：

shoppingList[0] = "Six eggs"
// 其中的第一項現(xiàn)在是 "Six eggs" 而不是 "Eggs"

還可以利用下標(biāo)來一次改變一系列數(shù)據(jù)值，即使新數(shù)據(jù)和原有數(shù)據(jù)的數(shù)量是不一樣的锤悄。下面的例子把"Chocolate Spread"韧骗，"Cheese"，和"Butter"替換為"Bananas"和 "Apples"：

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 現(xiàn)在有6項

注意：
不可以用下標(biāo)訪問的形式去在數(shù)組尾部添加新項铁蹈。

數(shù)組的屬性和方法##

Swift語言中數(shù)組同樣有很多操作方法宽闲，這里只介紹主要的幾個众眨。
可以使用數(shù)組的只讀屬性count來獲取數(shù)組中的數(shù)據(jù)項數(shù)量：

print("The shopping list contains \(shoppingList.count) items.")
// 輸出 "The shopping list contains 2 items."（這個數(shù)組有2個項）

使用布爾值屬性isEmpty作為檢查count屬性的值是否為 0 的捷徑：

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list is not empty.")
}
// 打印 "The shopping list is not empty."（shoppinglist 不是空的）

也可以使用append(_:)方法在數(shù)組后面添加新的數(shù)據(jù)項：

shoppingList.append("Flour")
// shoppingList 現(xiàn)在有3個數(shù)據(jù)項握牧，有人在攤煎餅

除此之外，使用加法賦值運算符（+=）也可以直接在數(shù)組后面添加一個或多個擁有相同類型的數(shù)據(jù)項：

shoppingList += ["Baking Powder"]
// shoppingList 現(xiàn)在有四項了
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 現(xiàn)在有七項了

調(diào)用數(shù)組的insert(_:atIndex:)方法來在某個具體索引值之前添加數(shù)據(jù)項：

shoppingList.insert("Maple Syrup", atIndex: 0)
// shoppingList 現(xiàn)在有7項
// "Maple Syrup" 現(xiàn)在是這個列表中的第一項

這次insert(_:atIndex:)方法調(diào)用把值為"Maple Syrup"的新數(shù)據(jù)項插入列表的最開始位置娩梨，并且使用0作為索引值沿腰。

類似的我們可以使用removeAtIndex(_:)方法來移除數(shù)組中的某一項。這個方法把數(shù)組在特定索引值中存儲的數(shù)據(jù)項移除并且返回這個被移除的數(shù)據(jù)項（我們不需要的時候就可以無視它）：

let mapleSyrup = shoppingList.removeAtIndex(0)
// 索引值為0的數(shù)據(jù)項被移除
// shoppingList 現(xiàn)在只有6項狈定，而且不包括 Maple Syrup
// mapleSyrup 常量的值等于被移除數(shù)據(jù)項的值 "Maple Syrup"

注意：
如果我們試著對索引越界的數(shù)據(jù)進行檢索或者設(shè)置新值的操作颂龙，會引發(fā)一個運行期錯誤习蓬。我們可以使用索引值和數(shù)組的count屬性進行比較來在使用某個索引之前先檢驗是否有效。除了當(dāng)count等于 0 時（說明這是個空數(shù)組）措嵌，最大索引值一直是count - 1躲叼，因為數(shù)組都是零起索引。

數(shù)據(jù)項被移除后數(shù)組中的空出項會被自動填補企巢，所以現(xiàn)在索引值為0的數(shù)據(jù)項的值再次等于"Six eggs"：

firstItem = shoppingList[0]
// firstItem 現(xiàn)在等于 "Six eggs"

如果我們只想把數(shù)組中的最后一項移除枫慷，可以使用removeLast()方法而不是removeAtIndex(_:)方法來避免我們需要獲取數(shù)組的count屬性。就像后者一樣浪规，前者也會返回被移除的數(shù)據(jù)項：

let apples = shoppingList.removeLast()
// 數(shù)組的最后一項被移除了
// shoppingList 現(xiàn)在只有5項或听，不包括 Apples

// apples 常量的值現(xiàn)在等于 "Apples" 字符串

數(shù)組的遍歷

我們可以使用for-in循環(huán)來遍歷所有數(shù)組中的數(shù)據(jù)項：

for item in shoppingList {
    print(item)
}
// Six eggs

// Milk
// Flour
// Baking Powder
// Bananas

如果我們同時需要每個數(shù)據(jù)項的值和索引值程剥，可以使用enumerate()方法來進行數(shù)組遍歷脚猾。enumerate()返回一個由每一個數(shù)據(jù)項索引值和數(shù)據(jù)值組成的元組。我們可以把這個元組分解成臨時常量或者變量來進行遍歷：

for (index, value) in shoppingList.enumerate() {
    print("Item \(String(index + 1)): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

更多關(guān)于for-in循環(huán)的介紹請參見for 循環(huán)恍涂。

Swift數(shù)組##

Swift中有內(nèi)置的字符串（String）類型缸濒。String是例如"hello, world"足丢，"albatross"這樣的有序的Character（字符）類型的值的集合。通過String類型來表示绍填。 一個String的內(nèi)容可以用變量的方式讀取霎桅，它包括一個Character值的集合。
創(chuàng)建和操作字符串的語法與 C 語言中字符串操作相似讨永，輕量并且易讀滔驶。 字符串連接操作只需要簡單地通過+符號將兩個字符串相連即可。與 Swift 中其他值一樣卿闹，能否更改字符串的值揭糕，取決于其被定義為常量還是變量。你也可以在字符串內(nèi)插過程中使用字符串插入常量锻霎、變量著角、字面量表達成更長的字符串，這樣可以很容易的創(chuàng)建自定義的字符串值旋恼，進行展示吏口、存儲以及打印。
盡管語法簡易冰更，但String類型是一種快速产徊、現(xiàn)代化的字符串實現(xiàn)。 每一個字符串都是由編碼無關(guān)的 Unicode 字符組成蜀细，并支持訪問字符的多種 Unicode 表示形式（representations）舟铜。

字符串是值類型（Strings Are Value Types）
Swift 的String類型是值類型。 如果您創(chuàng)建了一個新的字符串奠衔，那么當(dāng)其進行常量谆刨、變量賦值操作塘娶，或在函數(shù)/方法中傳遞時，會進行值拷貝痊夭。 任何情況下刁岸，都會對已有字符串值創(chuàng)建新副本，并對該新副本進行傳遞或賦值操作她我。 值類型在 結(jié)構(gòu)體和枚舉是值類型 中進行了詳細描述难捌。

Swift 默認字符串拷貝的方式保證了在函數(shù)/方法中傳遞的是字符串的值。 很明顯無論該值來自于哪里鸦难，都是您獨自擁有的根吁。 您可以確信傳遞的字符串不會被修改，除非你自己去修改它合蔽。

在實際編譯時击敌，Swift 編譯器會優(yōu)化字符串的使用，使實際的復(fù)制只發(fā)生在絕對必要的情況下拴事，這意味著您將字符串作為值類型的同時可以獲得極高的性能沃斤。

簡易的創(chuàng)建和連接，方便的插值刃宵，對Unicode的強大支持……這些是Swift字符串的主要特點衡瓶。

其他具體內(nèi)容見《基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)》部分。