java中有date数组么_Java 数组

数组概述：

1、数组可以看成是多个相同数据类型数据的组合，对这些数据的统一管理。

2、数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

3、数组中的元素可以是任何类型，包括基本类型和引用类型。

一维数组的声明：

1、一维数组的声明方式：

type var[];   或type[] var;

例如:

int a1[];     int[] a2;    double b[];     Person[] p1;     String s1[];

2、java语言中声明数组时不能指定其长度(数组中元素的个数)，例如：

int a[5];　　//非法

数组对象的创建：

1、java中使用关键字new 创建数组对象，格式为：

数组名 = new 数组元素类型[数组元素个数]；

例如：

public class TestArray{

public static void main(String args[]){

int[] arr;

arr = new int[5];

for(int i=0;i<5;i++){

arr[i] = i;

System.out.println(arr[i]);

}

}

}

2、元素为引用类型的数据(注意：元素为引用数据类型的数组中的每一个元素都需要实例化)

例如：

public class TestArray{

public static void main(String args[]){

Date[] date;

date = new Date[3];

for(int i=0; i<3; i++){

date[i] = new Date(2014,10,25);

System.out.println(date[i].year+"年，"+date[i].month+"月，"+date[i].day+"日！");

}

}

}

class Date{

int year,month,day;

public Date(int year,int month,int day){

this.year = year;

this.month = month;

this.day = day;

}

}

数组初始化：

1、动态初始化：

数组定义与为数组元素分配空间和赋值的操作分开进行，例如：

public class TestArray{

public static void main(String args[]){

int[] arr = new int[3]; //数组定义

arr[0]=1; //数组初始化

arr[1]=2;

arr[2]=3;

Date[] date = new Date[3]; //数组定义

date[0] = new Date(2014,10,25); //数组初始化

date[1] = new Date(2014,10,25);

date[2] = new Date(2014,10,25);

}

}

class Date{

int year,month,day;

public Date(int year,int month,int day){

this.year = year;

this.month = month;

this.day = day;

}

}

2、静态初始化

在定义数组的同时就为数组元素分配空间并赋值，例如：

public class TestArray{

public static void main(String args[]){

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

Date[] date = {new Date(2014,10,25), new Date(2014,10,26), new Date(2014,10,27)};

}

}

class Date{

int year,month,day;

public Date(int year,int month,int day){

this.year = year;

this.month = month;

this.day = day;

}

}

3、数组元素的默认初始化：

数组时引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化，例如：

public class TestArray{

public static void main(String args[]){

int[] a = new int[3];

Date[] date = new Date[3];

System.out.println(a[2]);

System.out.println(date[2]);

}

}

class Date{

int year,month,day;

public Date(int year,int month,int day){

this.year = year;

this.month = month;

this.day = day;

}

}

数组元素的引用：

1、定义并用运算符new为之分配空间后，才可以引用数组中的每个元素，数组元素的引用方式为：

①、arrayName[index]

index为数组元素下标，可以使整形常亮或整形表达式。如：

a[3], b[i], c[6*i];

②、数组元素的下标从0开始；长度为n的数组的合法下标取值范围为：

0~n-1;

2、每个数组都有一个属性lendth(注：这里length是一个属性，不是方法，没有加括号()，我们这里特别说明是为了和String的length()方法做区别)指明他的长度，例如：

a.length的值为数组a的长度(元素个数)

注：

public static void main(String args[]){}

我们每个类中的主函数也有一个数组，名叫srgs,那么这个数组时干嘛用的呢？这个数组就好比，我们在命令行中注入 ipconfig -all 中的all. 我们可以在输入             java TestArray(类名) 23,12，aa,bbb  这个跟几个参数。然后可以在代码中输出来看到。

注(基础类型的包装类)：

基础类型的包转类， 基础类型是分配在栈内存中的  ， 包装类是分配在堆空间里面的  。

基础类型的包装类有：Boolean---boolean 、 Byte---byte 、 Character---char 、 Double---double  、 Float---float  、 Integer---int  、 Long---            long 、 Short---short   通常我们使用parsexxx()方法来将string类型转换为我们想要的数据类型。我们也可以使用string类型的valueOf()方法将想要的              数据类型转换为string类型。

下面我们举一个args[]参数和基础类型包装类一起使用的例子，用来计算+-x/：

public class TestArgs{

public static void main(String args[]){

if(args.length<3){

System.out.println("error~~~");

System.exit(0);

}

double b1 = Double.parseDouble(args[0]);

double b2 = Double.parseDouble(args[2]);

double b = 0;

if(args[1].equals("+")){

b = b1 + b2;

}else if(args[1].equals("-")){

b = b1-b2;

}else if(args[1].equals("x")){

b = b1*b2;

}else if(args[1].equals("/")){

b = b1/b2;

}else{

System.out.println("error operation!!!");

}

System.out.println(b);

}

}

下面举一个用ars输入10个数，并且用选择排序，从小到大排序的示例：

public class TestSortInt{

public static void main(String args[]){

int[] a = new int[args.length];

for(int i=0; i

a[i] = Integer.parseInt(args[i]);

}

int k,temp;

for(int i=0; i

k = i;

for(int j=i+1; j

if(a[k]>a[j]){

k=j;

}

}

if(k!=i){

temp = a[i];

a[i] = a[k];

a[k] = temp;

}

}

for(int i=0; i

System.out.print(a[i] + " ");

}

}

}

下面我们用数组里面装一个日期类型做排序的示例，用了冒泡排序。

public class TestDateSort{

public static void main(String args[]){

Date[] date = new Date[5];

date[0] = new Date(2006,5,4);

date[1] = new Date(2006,7,4);

date[2] = new Date(2008,5,4);

date[3] = new Date(2004,5,9);

date[4] = new Date(2006,5,4);

bubbleSort(date);

for(int i=0; i < date.length; i++){

System.out.println(date[i]);

}

}

public static Date[] bubbleSort(Date[] a){

int len = a.length;

for(int i=len; i>=1; i--){

for(int j=0; j

if(a[j].compare(a[j+1])>0){

Date temp = a[j+1];

a[j+1] = a[j];

a[j] = temp;

}

}

}

return a;

}

}

class Date{

private int year,month,day;

public Date(int year,int month,int day){

this.year = year;

this.month = month;

this.day = day;

}

public int compare(Date date){

return year>date.year?1

:year

:month>date.month?1

:month

:day>date.day?1

:day

:0;

}

public String toString(){

return "year,month,day ---- " +year+" - "+month+" - "+day;

}

}

下面我们用数组做一个数三退一的游戏，就是说，好多人围城一圈，数1,2,3三个数，数到3的人退出，剩余的人继续重新从1开始数数，知道剩下最后一个人，我们用数组求最后一个人是谁？

在这个示例中，我们假设有500个人手拉手围城一圈在数数，最后是下标为435这个人赢了，也就是第436个人赢了！~~~

public class Count3Quit{

public static void main(String args[]){

boolean[] arr = new boolean[500];

for(int i=0; i

arr[i] = true;

}

int leftCount = arr.length;

int count = 0;

int index = 0;

while(leftCount > 1){

if(arr[index] == true){

count++;

if(count == 3){

count = 0;

arr[index] = false;

leftCount --;

}

}

index ++;

if(index == arr.length){

index=0;

}

}

for(int i=0; i

if(arr[i]==true){

System.out.println(i);

}

}

}

}

有了数组之后，我们可以设计各种各样的排序算法。然后在排好序的时候，我们又可以设计各种各样的查找算法，接下来，我们用数组实现一个简单的二分法查找算法

public class TestSearch{

public static void main(String args[]){

int[] a = {12,23,41,53,24,57,32,52,98,43,19,73};

int postion = binarySearch(a,57);

System.out.println(postion);

}

public static int binarySearch(int[] a, int searchNum){

if(a.length==0)return -1;

int startFlag = 0;

int endFlag = a.length-1;

int m = (startFlag+endFlag)/2;

while(startFlag<=endFlag){

if(a[m] == searchNum){

return m;

}else if(a[m]

startFlag = m+1;

}else if(a[m]>searchNum){

startFlag = m+1;

}

m = (startFlag+endFlag)/2;

}

return -1;

}

}

二维数组：

1、二维数组可以看成是以数组为元素的数组。例如：

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

2、java中多维数组的声明和初始化应按从高维到低维的顺序进行，例如：

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

a[0] = new int[2];

a[1] = new int[4];

a[2] = new int[3];

int t1[][] = new int[][4];//这种声明是非法的

二维数组初始化：

1、静态初始化：

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

int intB[3][2] = {{1,2},{,2,3},{4,5}};//非法声明方式

2、动态初始化：

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

int b[][] = new int[3][];

b[0] = new int[2];

b[1] = new int[3];

b[2] = new int[5];

二维数组举例：

public class Test{

public static void main(String args[]){

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

for(int i=0; i

for(int j=0; j

System.out.print("["+i+"]"+"["+j+"]="+a[i][j]+" ");

}

System.out.println();

}

}

}

二维数组举例(引用类型的二维数组)：

public class Test{

public static void main(String args[]){

String s[][];

s = new String[3][];

s[0] = new String[2];

s[1] = new String[3];

s[2] = new String[2];

for(int i=0; i

for(int j=0; j

s[i][j] = new String("我的位置是："+i+","+j);

}

System.out.println();

}

for(int i=0; i

for(int j=0; j

System.out.print(s[i][j]+" ");

}

System.out.println();

}

}

}

数组的拷贝：

1、使用java.lang.system类的静态方法

public static void arrayCopy(object src,int srcPos,object dest,int destPos,int length){}

2、可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的lenght个元素。

3、如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常。

数据拷贝举例：

import java.lang.System;

public class TestArrayCopy{

public static void main(String args[]){

String[] s = {"Microsoft","IBN","Sun","Oracle","Apple"};

String[] sBak = new String[6];

System.arraycopy(s,0,sBak,0,s.length);

for(int i=0;i

System.out.print(sBak[i]+" ");

}

System.out.println();

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

int[][] intArrayBak = new int[3][];

System.arraycopy(intArray,0,intArrayBak,0,intArray.length);

intArrayBak[2][1] = 100;

for(int i=0;i

for(int j=0;j

System.out.print(intArray[i][j]+" ");

}

System.out.println();

}

}

}