java之数组 – 高杰才_Android

数组概述:

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<args.length; i++){
a[i]
= Integer.parseInt(args[i]);
}
int k,temp;
for(int i=0; i<a.length; i++){
k
= i;
for(int j=i+1; j<a.length; 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<a.length; 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<i-1; 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
<date.year?-1
:month
>date.month?1
:month
<date.month?-1
:day
>date.day?1
:day
<date.day?-1
:
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.length; 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<arr.length; 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]<searchNum){
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<a.length; i++){
for(int j=0; j<a[i].length; 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<s.length; i++){
for(int j=0; j<s[i].length; j++){
s[i][j]
= new String(“我的位置是:”+i+”,”+j);
}
System.out.println();
}
for(int i=0; i<s.length; i++){
for(int j=0; j<s[i].length; 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<sBak.length;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<intArray.length;i++){
for(int j=0;j<intArray[i].length;j++){
System.out.print(intArray[i][j]
+” “);
}
System.out.println();
}
}
}

到此为止,数据的基本知识就讲完了。学会了数组更重要的是为我们以后学习排序算法之类的~~打下了基础,这才是更重要的!!!

 

本文链接:java之数组,转载请注明。



You must enable javascript to see captcha here!

Copyright © All Rights Reserved · Green Hope Theme by Sivan & schiy · Proudly powered by WordPress

无觅相关文章插件,快速提升流量