-------android培训、java培训、期待与您交流！ ----------
一 数组的定义
数组是在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组织起来的一种形式。这些按序排列的同类数据元素的集合称为数组。
其实我觉得数组就是一个容器。
二 数组的好处
可以自动给数组中的元素从0开始编号，方便操作这些元素。
三 数组的格式
数组定义的第一种格式
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];
数组定义的第二种格式
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
示例：int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
四 内存结构
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存 在方法中定义的一些基本类型的变量（局部变量）和对象的引用变量都在方法的栈内存中分配，当在一段代码中定义一个变量时，java就在栈内存中为这个变量分配内存空间，当超出变量的作用域后，java会自动释放掉为该变量所分配的内存空间。
堆内存 堆内存用来存放由new运算符创建的对象（成员变量）和数组，在堆中分配的内存，由java虚拟机的自动垃圾回收器来管理。在堆中创建了一个数组或对象后，同时还在栈内存中定义一个特殊的变量。让栈内存中的这个变量的取值等于数组或者对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量，引用变量实际上保存的是数组或对象在堆内存中的地址（也称为对象的句柄），以后就可以在程序中使用栈的引用变量来访问堆中的数组或对象。
方法区 静态成员、构造函数、常量池、线程池
本地方法区 window系统占用
寄存器
五 数组的常见操作
1，获取数组中的元素
package blog.csdn.wz;
class ArrayTest
{
public static void main(String[] args)
{
int[] arr = {3,6,5,1,8,9,67};
printLength(arr);
printElement(arr);
printSum(arr);
printArray(arr);
}
//定义功能，获取数组的长度
public static void printLength(int[] arr)
{
System.out.println("length:"+arr.length);
}
//定义功能，获取数组中的元素
public static void printElement(int[] arr)
{
for(int x=0; x<arr.length; x++)
{
System.out.println("arr["+x+"]="+arr[x]+";");
}
}
//定义功能，用于打印数组元素的和
public static void printSum(int[] arr)
{
int sum=0;
for (int x=0;x<arr.length ;x++ )
{
sum +=arr[x];
}
System.out.println("sum="+sum);
}
//定义功能，用于打印数组中的元素。元素间用逗号隔开。
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
2，获取数组中的最值
package blog.csdn.wz;
class ArrayTest2
{
public static void main (String[] args)
{
int[] arr={1,2,3,6,9,4,8};
int min=getMin(arr);
int max=getMax(arr);
System.out.println("max="+max);
System.out.println("min="+min);
}
public static int getMax(int[] arr)
{
int max=arr[0];//初始化数组中的任意一个元素
for (int x=1;x<arr.length ;x++ )
{
if(arr[x]>max)
max=arr[x];
}
return 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];
}
}
注意：若获取其他类型数组的最值，重载
3，对给定的数组进行排序（选择排序与冒泡排序）
package blog.csdn.wz;
public class ArrayTest3 {
public static void main(String[] args)
{
int[] arr={1,4,6,7,8,3,90,43};
printArray(arr);//打印排序之前的数组
selectSort(arr);
printArray(arr);//打印选择排序之后的数组
bubbleSort(arr);
printArray(arr);//打印冒泡排序之后的数组
}
//给int数组进行选择排序（升序）。
public static void selectSort(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])//arr[x]<arr[y]则降序
{
swap(arr,x,y);
}
}
}
}
//给int数组进行冒泡排序（降序）。
public static void bubbleSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)//-x让每次比较的元素减少，-1避免角标越界
{
if(arr[y]<arr[y+1])//arr[y]>arr[y+1]则序升序
{
swap(arr,y,y+1);
}
}
}
}
//将选择排序和冒泡排序进行封装，没有必要提供出去，直接私有化，这叫做能隐藏起来的都隐藏起来
private static void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
//用于打印数组中的元素。打印形式是：[elemet1,elemet2、、、]
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0;x<arr.length;x++)
{
if (x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}
注意：真是开发用直接排序 Arrays.sort(arr);
4，查找元素在数组中的位置（普通查找与折半查找）
package blog.csdn.wz;
class ArrayTest4
{
public static void main(String[] args)
{
int[] arr={3,2,1,5,4,2,9};
int index=getIndex(arr,3);
System.out.println("index="+index);
int index2=halfSearch(arr,3);
System.out.println("index="+index2);
}
//普通查找
/*
获取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 halfSearch(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while (min<=max)
{
mid=(max+min)>>1;
if (key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return min;
}
}
5，进制转化
自己总结的放在数组这篇博客中，一起对比学习
package blog.csdn.wz;
public class ArrayTest5 {
public static void main(String[] args) {
toHex(60);
toBa(40);
toHex(60);
}
//将十进制转化为二进制
public static void toBin(int num)
{
trans(num,1,1);
}
//将十进制转化为八进制
public static void toBa(int num)
{
trans(num,7,3);
}
//将十进制转化为十六进制
public static void toHex(int num)
{
trans(num,15,4);
}
private 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];//定义一个临时容器
int pos=arr.length;//定义一个操作数组的指针
while(num!=0)
{
int temp=num&base;
arr[--pos]=chs[temp];
num=num>>>offset;
}
System.out.println("pos="+pos);
//存储数据的arr数组遍历
for (int x=pos;x<arr.length ;x++ )
{
System.out.print(arr[x]);
}
}
}
六 二维数组（数组中的数组）
格式1：int[][] arr = new int[3][2];
1 定义了名称为arr的二维数组
2 二维数组中有3个一维数组
3 每一个一维数组中有2个元素
4 一维数组的名称分别为arr[0], arr[1], arr[2]
5 给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
格式2 ：int[][] arr = new int[3][];
1 二维数组中有3个一维数组
2 每个一维数组都是默认初始化值null
3 可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
1 定义一个名称为arr的二维数组
2 二维数组中的有三个一维数组
3 每一个一维数组中具体元素也都已初始化
4 第一个一维数组 arr[0] = {3,8,2};
5 第二个一维数组 arr[1] = {2,7};
6 第三个一维数组 arr[2] = {9,0,1,6};
7 第三个一维数组的长度表示方式：arr[2].length;