数组的概述
数组可以看成是多个相同类型的数据的组合，对这些数据的统一管理
数组变量属于引用类型，也可以看成是对象，数组中的每个元素相当于该对象的成员变量
数组中的元素可以是任何数据类型，包括基本类型和引用类型
一维数组
一位数组的声明方式：
type var[]
type[] var
例：int a1[]
double b[]
Person[] p1
String s1
注意：Java语言中声明数组不能指定其长度（数组中元素的个数），例：int a[5]
一维数组创建的内存图
int[] s
s=new int[5]
for(int i = 0;i<5;i++){s[i] = i}
元素为引用数据类型的数组内存图
代码如下：
class Date{
int year;
int month;
int day;
Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
}
public class Test {
public static void main(String[] args){
Date[] days;
days = new Date[3];
for(int i = 1;i<=3;i++){
days [i-1] =new Date(2017,7,i);
}
}
}
数组的初始化
1、动态初始化
数组定义与为数组元素分配空间和赋值的操作时分开的（如上面例子中数组days）
2、静态初始化
在定义数组的时候就为数组元素分配空间并赋值
例如将上面代码改为
class Date{
int year;
int month;
int day;
Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
}
public class Test {
public static void main(String[] args){
Date[] days = {
new Date(2017,7,1),
new Date(2017,7,2),
new Date(2017,7,3)
};
}
}3、数组元素的默认初始化
数组是引用类型，它的元素相当于成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式的初始化
数组元素的引用
定义并运用运算符new为之分配空间后，才可以引用数组中的每个元素，数组元素的饮用方式为
数组名 [索引（index）]
索引为数组元素下标，可以是整型常量或者整型表达式
如：a[3],b[i],c[6*i]
数组元素下标从0开始，长度为n的数组的合法下标取值范围为0~n-1
每个数组都有一个**属性**length指明它的长度
a.length的值为数组a的长度（元素个数）
数组其他
1、输出数组元素
只需要一个简单的循环就可以
public class TestArray {
public static void main(String[] args) {
int a[] = {1,5,6,4,3,7,8,9,2};
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}输出结果
1 5 6 4 3 7 8 9 2 java中main方法里面的String[] args（String args[]）的意思
String[] 是指一个String类型的数组，args是函数的形参，可理解为“入口参数”,Java本身不存在不带Stringargs[]的main方法
String[] args 这个字符串数组是保存运行main函数时输入的参数的，例如main方法所在的类名为Test那么你在cmd运行 java Test a b c 时，那么args[0] = a ,args[1]=b, args[2]=c，并且可以在程序中调用这些变量
看一个例子
public class TestArray {
public static void main(String[] args) {
if (args.length < 3) {
System.out.println("Usage: java Test \"n1\" \"op\" \"n2\"");
System.exit(-1); //非正常退出，0为正常退出
}
double d1 = Double.parseDouble(args[0]);
double d2 = Double.parseDouble(args[2]);
double d = 0;
if (args[1].equals("+"))
d = d1 + d2;
else if (args[1].equals("-"))
d = d1 - d2;
else if (args[1].equals("x"))
d = d1 * d2;
else if (args[1].equals("/"))
d = d1 / d2;
else {
System.out.println("Error operator!");
System.exit(-1);
}
System.out.println(d);
}
}执行如下
实际上就是一个实现计算的小程序
上面例子中有一个parseDouble方法解释一下
一般情况下基本数据类型分配在栈上面，但有一系列基础类型的包装类可以通过创建对象使其分配在堆内存，如class Byte，class Boolean， class Integer（包装int类型）等
可以通过这些包装类的例上例中parseDouble()方法将String类型转换为Double类型（查询API文档可知方法实际是static double parseDouble(String s)）,其他基本数据类型方法类似
但是像类似于asdaf这样的字符串无法转换为Double类型，则报NumberFormatException错误
具体可参照本人另一篇博客
Java常用类之基础数据类型包装类
2、将（1）中例子排序（选择排序）后输出
public class TestSort {
public static void main(String[] args) {
int[] a = { 1, 5, 6, 4, 3, 7, 8, 9, 2 };
print(a);
selectionSort(a);
print(a);
}
private static void print(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}
private static void selectionSort(int[] a) {
for (int i = 0; i < a.length; i++) {
for (int j = i + 1; j < a.length; j++) {
if (a[i] > a[j]) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
}
}
输出结果
1 5 6 4 3 7 8 9 2
1 2 3 4 5 6 7 8 9 方法的返回值类型可以是数组（的引用）类型，如下
public class BubbleSort {
public static void main(String[] args) {
Date[] days = new Date[5];
days[0] = new Date(2006, 5, 4);
days[1] = new Date(2006, 7, 4);
days[2] = new Date(2008, 5, 4);
days[3] = new Date(2004, 5, 9);
days[4] = new Date(2004, 5, 4);
//排序前
for (int i = 0; i < days.length; i++) {
System.out.println(days[i]);
}
System.out.println();
bubbleSort(days);
//排序后
for (int i = 0; i < days.length; i++) {
System.out.println(days[i]);
}
}
public static Date[] bubbleSort(Date[] a) {
int len = a.length;
for (int i = len - 1; i >= 1; i--) {
for (int j = 0; j <= i - 1; j++) {
if (a[j].compare(a[j + 1]) > 0) {
Date temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
return a;
}
}
class Date {
int year, month, day;
Date(int y, int m, int d) {
year = y;
month = m;
day = d;
}
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;
}
}冒泡排序日期，输出结果
排序前
Year:Month:Day -- 2006-5-4
Year:Month:Day -- 2006-7-4
Year:Month:Day -- 2008-5-4
Year:Month:Day -- 2004-5-9
Year:Month:Day -- 2004-5-4
排序后
Year:Month:Day -- 2004-5-4
Year:Month:Day -- 2004-5-9
Year:Month:Day -- 2006-5-4
Year:Month:Day -- 2006-7-4
Year:Month:Day -- 2008-5-4
3、排好序的数进行二分查找（简单快速）
public class TestSearch {
public static void main(String[] args) {
int a[] = { 1, 3, 6, 8, 9, 10, 12, 18, 20, 34 };
int i = 12;
System.out.println(binarySearch(a, i));
}
//一般的查找方法
/*public static int search(int[] a, int num) {
for(int i=0; i<a.length; i++) {
if(a[i] == num) return i;
}
return -1;
}*/
public static int binarySearch(int[]a, int num) {
if (a.length==0) return -1;
int startPos = 0;
int endPos = a.length-1;
int m = (startPos + endPos) / 2;
while(startPos <= endPos){
if(num == a[m]) return m;
if(num > a[m]) {
startPos = m + 1;
}
if(num < a[m]) {
endPos = m -1;
}
m = (startPos + endPos) / 2;
}
return -1;
}
}二维数组
二维数组可以看成以数组为元素的数组，例如int a[][] = {{1,2},{3,4,5},{6}}
Java中多维数组的声明和初始化应按照从高维到低维的顺序进行
int a[][] = new int[3][];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
//不能空缺第一维大小，故下面定义是非法的
//int[][] b = new int[][3];内存情况如下
二维数组初始化
类似于一维数组，但是不能int a[3][2] = {{1,2},{3,4},{5,6}}[]中数字Java自己确定
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);
}
}
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();
}输出结果
我的位置时是 0 ，0 我的位置时是 0 ，1
我的位置时是 1 ，0 我的位置时是 1 ，1 我的位置时是 1 ，2
我的位置时是 2 ，0 我的位置时是 2 ，1
数组的拷贝
使用的是Java.lang.System类的静态方法
public static void arraycopy
(Object src,int srcPos,Oject dest,int destPos,int length)数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置
如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常
public class TestArrayCopy {
public static void main(String args[]) {
String[] s = { "Mircosoft", "IBM", "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();
}
}
}
输出结果
Mircosoft IBM Sun Oracle Apple null（当引用为空值时为null）
1 2
1 2 3
3 100 
224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
