黑马程序员_Java基础_数组

-------
android培训、java培训、期待与您交流！ ----------

一、数组

同一种类型数据的集合,也就是一个容器。

声明：

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

例：int[] arr = new int[5];

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

例：int arr[] = new int[5];

3.元素类型[]数组名 = new元素类型[]{元素1，元素2，元素3，......}；

例：int[] arr =new int[]{1,2,3,4};

int[] arr={1,2,3,4}

注：

JAVA中推荐用：类型[]数组名;

一个数组是一个对象

声明一个数组没有创建一个对象

声明时不用指定长度

创建基本数据类型数组：int[] i = new int[2];

创建引用数据类型数组：Student[] s = new Student[100];

数组创建后其中的元素有初始值

类型 黙认值

byte 0

short 0

int 0

long 0l

float 0.0f

double 0.0d

char \u0000

boolean false

reference types null

注：

创建时一定要指定长度

int[] i2=new int[]; //error

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：

1. 数组和对象，通过new建立的实例都是存放在堆内存中。

2. 每一个实体都有默认初始化值。

3. 实体中的变量都有默认初始化值。

4. 实体不在被使用，会在不确定的时间内被垃圾回收器回收。

栈内存：自动释放。堆内存：垃圾回收机制。

Java的垃圾回收：

由一个后台线程gc进行垃圾回收

虚拟机判定内存不够的时候会中断代码的运行，这时候gc才进行垃圾回收

缺点：不能够精确的去回收内存

java.lang.System.gc(); 建议回收内存，但系统不一定回应，他会先去看内存是否够用，够用则不予理睬，不够用才会去进行垃圾回收

内存中什么算是垃圾：不在被引用的对象(局部变量，没有指针指向的)

二、数组的遍历

示例：

遍历数组

/*
遍历数组
*/
class Test
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5,6,7};
printArray(arr);//调用自定义函数
}
public static void printArray(int[] arr)//自定义遍历一维数组函数
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
}
}

三、获取数组中最大值和最小值

/*
获取一维数组中的最大值和最小值
*/
class ArrayTest
{

public static int getMax(int[] arr)//获取最大值函数
{
int max=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;//存储最大值数组元素的脚标
}
return arr[max];
}
public static int getMin(int[] arr)//获取最小值函数
{
int min=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min=x; //存储最值数组元素的脚标
}
return arr[min];
}

public static void main(String[] args)
{
int[] arr={1,3,2,5,5};
System.out.println("max="+getMax(arr)+"\n"+"min="+getMin(arr));
}
}

四、数组元素排序（选择排序）

/*
需求：选择排序
思路：
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的
数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
*/
class ArrayTest2
{
public static void selectSort(int[] arr) //选择排序
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])//默认从小到大排序，需要从大到小排序，将“>”改为“<”
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;

}

}
}
}

public static void printArray(int[] arr)//自定义遍历一维数组函数
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
}

public static void main(String[] args)
{
int[] arr={1,3,4,6,2,7,5};
System.out.print("排序前：");//排序前
printArray(arr);//调用打印函数

System.out.print("\n排序后：");//排序后
selectSort(arr);//调用排序函数
printArray(arr);//排序后
}
}

五、数组元素排序（冒泡排序）

/*
需求：冒泡排序
思路：
冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个
数比后一个数大（则升序，小则降序）则交换两数
*/
class ArrayTest2
{

public static void bubbleSort(int[] arr)//冒泡排序
{
for(int x=0;x<arr.length-1;x++)//控制冒泡次数
{
for(int y=0;y<arr.length-1-x;y++)//控制比较次数
{
if(arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;

}
}
}
}

public static void printArray(int[] arr)//自定义遍历一维数组函数
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
}

public static void main(String[] args)
{
int[] arr={1,3,4,6,2,7,5};
System.out.print("排序前：");//排序前
printArray(arr);//调用打印函数

System.out.print("\n排序后：");//排序后

bubbleSort(arr);//调用冒泡排序函数
printArray(arr);//排序后
}
}

六、数组元素排序（位置置换功能抽取）

发现无论什么排序。都需要对满足条件的元素进行位置置换，所以可以把这部分代码提取出来，单独封装成一个函数。

/*
需求：冒泡排序
思路：
冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个
数比后一个数大（则升序，小则降序）则交换两数
*/
class ArrayTest2
{
public static void bubbleSort(int[] arr)//冒泡排序
{
for(int x=0;x<arr.length-1;x++)//控制冒泡次数
{
for(int y=0;y<arr.length-1-x;y++)//控制比较次数
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
}
}
}
}

public static void swap(int[] arr,int a,int b)//交换
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;

}

public static void printArray(int[] arr)//自定义遍历一维数组函数
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
}

public static void main(String[] args)
{
int[] arr={1,3,4,6,2,7,5};
System.out.print("排序前：");//排序前
printArray(arr);//调用打印函数

System.out.print("\n排序后：");//排序后
bubbleSort(arr);//调用冒泡排序函数
printArray(arr);//排序后
}
}

技巧：引入import java.util.*;通过Arrays.sort();也可以进行数组排序。

七、折半查找

/*
数组元素的查找操作

*/
class ArrayTest3
{
public static void main(String[] args)
{
int[] arr={2,3,4,6,8,64,78};
//int index=getIndex(arr,2);//遍历查找

//int index=halfSearch(arr,8);//折半查找方法1

int index=halfSearch_2(arr,8);//折半查找方法2

System.out.println("index="+index);
}

//折半查找，前提是数组元素是有序的。
public static int halfSearch(int[] arr,int key)//方法1
{
int min,max,mid;
min=0;
max=arr.length-1;
mid=(max+min)/2;

while(arr[mid]!=key)
{
if(key>arr[mid])
{
min=mid+1;
}
else if(key<arr[mid])
{
max=mid-1;
}

if(min>max)
return -1;

mid=(max+min)/2;
}
return mid;
}

public static int halfSearch_2(int[] arr,int key)//方法2
{
int min=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(max+min)/2;

if(key>arr[mid])
{
min=mid+1;
}
else if(key<arr[mid])
{
max=mid-1;
}
else
return mid;
}
return -1;
}

//定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。
public static int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
}

//练习：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的。
public static int getIndex_2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(max+min)/2;

if(key>arr[mid])
{
min=mid+1;
}
else if(key<arr[mid])
{
max=mid-1;
}
else
return mid;
}
return min;//返回要插入的具体位置

}

八、十进制->二进制和十进制->十六进制

/*
十进制->二进制和十进制->十六进制
*/
class ArrayTest4
{
public static void main(String[] args)
{
toBin(60);//十进制->二进制
toHex(60);//十进制->十六进制
}

public static void toBin(int num)//十进制->二进制函数
{
StringBuffer sb=new StringBuffer();
while(num>0)
{
sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse());
}

public static void toHex(int num)//十进制->十六进制函数
{
StringBuffer sb=new StringBuffer();

for(int x=0;x<8;x++)
{
int temp=num&15;
if(temp>9)
{
sb.append((char)(temp-10+'A'));
}
else
{
sb.append(temp);
}
num=num>>>4;
}
System.out.println(sb.reverse());
}

}

九、查表法进行十进制->十六进制和十进制->二进制

/*
查表法进行十进制->十六进制和十进制->二进制
*/
class ArrayTest5
{
public static void main(String[] args)
{
toHex(60);
toBin(60);
}
/*
0 1 2 3 4 5 6 7 8 9 A  B  C  D  E  F  (十六进制中的元素)
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

查表法：将所有的元素临时存储起来，建立对应关系。
每一次&15后的值作为索引去查建立好的表，就可以找到对应的元素。

可以通过数组的形式去定义。
*/
public static void toHex(int num)//查表法16进制
{
char[] chs={'0','1','2','3','4',
'5','6','7','8','9',
'A','B','C','D','E','F'
};//定义二进制表
char[] arr=new char[8];//定义一个临时存储容器，元素默认值'\u0000'。
int pos=arr.length;

while(num!=0)
{
int temp=num&15;
arr[--pos]=chs[temp];
num=num>>>4;
}
for(int x=pos;x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();//换行
}

public static void toBin(int num)//查表法2进制
{
char[] chs={'0','1'};//定义二进制表
char[] arr=new char[32];//定义一个临时存储容器
int pos=arr.length;

while(num!=0)
{
int temp=num&1;
arr[--pos]=chs[temp];
num=num>>>1;
}

for(int x=pos;x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();//换行
}
}

十、进制转换优化

/*
进制转换优化
*/
class ArrayTest6
{
public static void main(String[] args)
{
toBin(-3);
toOctal(30);
toHex(-20);
}

public static void toBin(int num)//十进制->二进制
{
trans(num,1,1);
}

public static void toOctal(int num)//十进制->八进制
{
trans(num,7,3);
}

public static void toHex(int num)//十进制->十六进制
{
trans(num,15,4);
}

public static void trans(int num,int base,int offset)
{
if(num==0)
{
System.out.println(0);
return;
}

char[] chs={'0','1','2','3','4',
'5','6','7','8','9',
'A','B','C','D','E','F'
};
char[] arr=new char[32];//默认值'\u0000'
int pos=arr.length;

while(num!=0)
{
int temp=num&base;
arr[--pos]=chs[temp];
num=num>>>offset;
}
for(int x=pos;x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();//换行
}
}

十一、 二维数组

(其实是一个一维数组，它的每一个元素又是一个一维数组)

int[][] i1 = new int[2][3];

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

int[][] i3 = new int[][3]; //不允许高维没分配空间而先给低维分配空间

int[][] i2 = new int[2][];

i2[0] = new int[2];

i2[1] = new int[3];

注意：

int[] x,int x[];//一维

int[][]y;int y[][]; int[] y[];//二维

int[] x,y[];//x一维，y二维

也就是：

int[] x;

int[] y[];

1.x[0]=y;//error

2.y[0]=x;//yes

3.y[0][0]=x;//error

4.x[0][0]=y;//error

5.y[0][0]=x[0];//yes

6.x=y;//error

练习：

/*
二维数组遍历

*/
class ArrayTest7
{
public static void main(String[] args)
{
int a[][]=new int[][]{{1},{1,2},{1,2,3},{1,2,3,4}};//定义二维数组
for(int i=0;i<a.length;i++)
{	for(int j=0;j<a[i].length;j++)
{
System.out.print(a[i][j]);
}
System.out.println();//换行
}
}
}

-------
android培训、java培训、期待与您交流！ ----------　　详细请查看：http://edu.csdn.net/heima/