Java笔记系列（基于马士兵的课堂）（3）-数组

                                 数组                                   

数组：数组十多个相同类型的数据组合，对这些数据进行统一的管理，java中数组变量属于引用类型，数组也可以看作对性，数组中每个元素相当于其专属的成员变量，数组中的元素可以是任何类型（当然包括引用类型）

一维数组：一维数组的声明：int a1[];（也可以写成 int [] a1;）Person[] b1；

数组的各部分，在java中都在栈内存上（不可动态）

完成>

数组对象的创建：int[] s;s=new int[5];(在堆空间中分配5个小格，每个小格系统自动初始化，与类的成员变量初始化相同，全部是0，Boolean类型是false，引用类型是空值<除了几种基本类型，剩余都是引用类型>[注意角标从0开始算起])

注意new出来的数组（例如days（一个角标）在占空间中指向在堆空间中分配的小格（一个角标指向一个小格））

数组的初始化：分为动态初始化，和静态初始化。

数组一定先分配空间，再向其中赋值。

静态初始化：在定义数组的同时就维数组元素非配空间并赋值。5

Inta[]=（3,9,8）；5

赋值之后可以调用数组内的值，用arryName[index]来调用，其中index可以是值，也可以是整型表达式，注意下标从0开始【勿忘可能越界】。

每个数组有他的属性length来指明其长度。A.length来表示a的长度（这是一个属性，与String不同，String中length是一个方法，勿忘加括号）。

Args也是一个数组（在main方法中）<命令行参数有几个，args的输出，内容就有几个>

System.exit(0  或-1);<0正常退出，-1非正常退出>

可以将基础类型变量包装成一个对象，这样这个变量就可以存在数组中，并且在堆空间中分配给其一定的空间。（如char Character<在javalang里>）

double d1=Double.parseDouble（args[2]）；（将第二个数值变成一个对象）

注意初学者应先主后次（先完成程序的书写有序，没有错误，在考虑程序的健壮性友好性）

注意经典的for循环嵌套，从而得到Arrays（test7，排序arrays）

注意算法的效率，多余的步骤在某种程度上降低了算法效率，要想成为一名系统级别的程序员应该注意算法的效率，数据结构。

(排序算法，；拉圈问题；搜索算法（一个搜索算法往往建立在排序算法之上）；)

返回值如果是数组可以在方法中写入（int [],或者一个数组的引用person[]）

返回值其实也是在栈内存中指向和数组名相同的堆空间内存。

数组是引用类型时，引用的对象在堆内存中，栈内存中有数组名指向堆内存中的数组小格，数组小格有分别指向每个对象的地址，同时每个数组小格又被下标所指。

直接打印对象相当于调用toString方法。

数组可以模拟链表，如果想用这种方法使某小格退出，可以让退出小格中的内容变成下一个小格的位置（地址），然后就成了一个链表。（一个节点拉着一个节点，叫做链表，连续拉着叫双向回环链表）

搜索算法

搜算算发往往先将数组排序，然后用二分法。取中间值大的向右，小的向左，等于刚刚好。

二维数组

二维数组可以看成以数组为元素的数组（二维数组两个大括号）多维也是。

Java中多维数组的声明应该从高维，到低维进行声明初始化（即从左至右进行声明）

Int[][]a=new int [2] [];   因为每个二维数组指向内存空间中的多个一维数组，一维数组又向内存空间中的多个小格。如此相当于数组的引用。（先二维数组申请空间）

Int a[][]=new int [3][];

a[0]=new int [2]（指向的一维数组有了两个小格）

a[1]=new int[3]（所指向的一维数组有了三个小格）

a[2]=new int[4]（所指向的一维数组有了四个小格）

多维数组相当于一颗分支树。

二维数组初始化：

静态初始化：int a[][]={{1,2}}{3,4}}//前面的小格不能填任何数，java自行检查。

动态初始化：int a[][]=new int [3][5];(每个一维数组的成员相同)

分开写，先2 后1 每个一维数组的成员数不相同。

数组成员的访问：

A[0][1]第一个一维数组的第二个成员。

（a.        length）指的是共有几个一维成员数组。

（a[i].length）指的是第i+1个成员一维数组的长度。

数组的拷贝：

数组往往在内存中是成块的区域，如果想高效率的拷贝，往往不是调用被拷贝数组的每一个只值，而是直接拷贝这块区域的内存，使两个数组相同（memory copy<c语言中>）

Java.lang.System中有一个方法，叫arraycopy，如果超出边界会抛出异常。

System.arraycopy(已定义数组<被拷贝>，起始位置<角标>，拷贝数组<也需要定义完毕>,终止位置，拷贝长度)

（他们指向相同的对象，如果有多余非0即null）

二维数组拷贝，将指向相同的成员一维数组。

总结：

数组本身语法，内容并不很多，但由于数组设及算法较多，所以要注意数组的算法（更有效率），数组是一种引用类型，要注意数组的内存空间分配（一小块内存指向一大块内存）。

注意：作为引用类型的组，在for循环赋值之前，一定要初始化数组中的每一个对象，让他们在堆内存中分配空间，这样之后在使用循环赋值数组中每个对象的属性就轻而易举。

附录代码：

选择排序：

package Arry;


import java.util.Scanner;/*用一个记录当前最小的数的记录器*/


public class Arrays2 {
public static void  main(String args[]){
Scanner s=new  Scanner(System.in);
System.out.println("输入数组长度：");
int m=s.nextInt();
int []b=new int[m];
System.out.println("输入数组成员（整数）：");
for (int x=0,n;x<b.length;x++){
n=s.nextInt();
b[x]=n;

}
   sort(b);
print(b);

  }private static void print(int []a){
for(int i = 0;i<a.length;i++){
System.out.println(a[i]+" ");
}
}
private static void sort(int []d){
for (int j=0,m;j<d.length;j++){
int k=j;
for(int i=k+1;i<d.length;i++){
if(d[i]<d[k]){
k=i;
    }
  }
if (k!=j){
m=d[j];
d[j]=d[k];
d[k]=m;
  }//记录最小值的位置，并将最小值依次付给数列中的效率更高 .数据结构，算法应该是必备的，追求效率。
}
}
}

这里再附上三种常用的排序方法：

冒泡排序，选择排序，希尔排序

package SORT;


public class sort1 {
public static void main(String args[]){
int []a={1,2,3,3,2,1,5,1,-1,-4,-8,2,9};
int []b={1,2,3,3,2,1,5,1,-1,-4,-8,2,9};
int []c={1,2,3,3,2,1,5,1,-1,-4,-8,2,9};
sPao(a);
print(a);
sChoose(b);
print(b);
sXier(c);
print(c);
}
public static void sPao(int a[]) {
int  k;
int count=0;
for (int i=0;i<a.length;i++){
for (int j=i;j<a.length;j++){
if(a[i]>a[j]){
k=a[i];
a[i]=a[j];
a[j]=k;
}
count++;
}
}
System.out.println("{"+count+"}");

}
public static void sChoose(int a[]){
int m;
int count=0;
for (int j=0;j<a.length;j++){
int k=j;
for(int i=k+1;i<a.length;i++){
if(a[i]<a[k]){
k=i;
    }
count++;
  }
if (k!=j){
m=a[j];
a[j]=a[k];
a[k]=m;
  }//记录最小值的位置，并将最小值依次付给数列中的效率更高 .数据结构，算法应该是必备的，追求效率。
}
System.out.println("{"+count+"}");
}

public static void sXier(int []a){
int N=a.length;
int h=1;
int count=0;
while(h<N/3){
h=3*h+1;
}
   while(h>=1){
    for(int i=h;i<N;i++){
    for (int j=i;j>=h&&a[j]<a[j-h];j-=h,count++){
    int m=a[j];
    a[j]=a[j-h];
    a[j-h]=m;
    }
    }
    h=h/3;
   }
   System.out.println("{"+count+"}");
 
  }
public static void print(int a[]){
for (int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
}