-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
Java的数组要点总结
1、数组是基本数据类型和字符串类型的容器（引用数据类型），而集合是类数据类型的容器；
2、数组定义的格式：
（1）一般格式：
元素类型[] 数组名 = new 元素类型[元素个数或者数组长度]；
其中，元素类型[] 数组名是一个引用数据类型，存放在栈中；
new 元素类型[元素个数或者数组长度]存放在堆中数组对象，继承自Object。
（2）定义和静态初始化
元素类型[] 数组名 = {,,}；
元素类型[] 数组名 = new 元素类型[元素个数或者数组长度]{
,,,,,,,}；
注意：别忘了末尾的；
3、未初始化的数组的默认值问题，就是保存的基本类型的默认初始值
int[] rfInit = new int[3];
System.out.println(rfInit[0]);//0
String[] strInit = new String[3];
System.out.println(strInit[0]);//null
4、数组使用中常见问题
（1）数组越界:编译没有问题，但运行时报错。
int[] arr = new int[3];
System.out.println(arr[3]);
//ArrayIndexOfBoundsException3：操作数组时，访问到了
数组中不存在的角标。
注：角标的最大值是长度减1；
（2）数组指向错误
String[] strNull = null;
System.out.println(strNull[0]);
//NullPointException ：空指针异常，当引用没有任何指向为
null的情况，该引用还在用于操作实体。
5、数组引用值：
int[] a = {1,2,3,4};
System.out.println(a);
//结果： [I@1db9742 ，这个就是数组的引用值；其中，
[表示为数组，I表示存放类型，1db9742哈希值表示在内存中的存放
的十六进制地址。
6、数组操作（算法）
遍历、最大/最小值、排序（冒泡、选择和直接插入）、查找（折半）、删除数组元素操作
和进制转化
（1）遍历
int[] arr = new int[3];
通过数组的属性arr.length可以获取数组的长度。
（2）最大/最小值：
a、存放值
（注：不能把存放最大值的变量赋值为0，因为数组中有负数，就会产生问题。）
b、存放角标
（注：存放角标的值可以为0，因为它代表数组的0角标数据）
（3）排序：从小到大
a、选择：内循环一次比较，选择出最小的放在最前面，所以减少前面
比较完的数量；（注：暂时保存最大或者最小值下标，最后再交换是一个
优化的方法。）
b、冒泡：内循环一次比较，最小值向前移动，最大值的沉底；所以减少
后面比较完的数量,
-x:让每一次比较的元素减少，-1：避免角标越界。
c、直接插入排序：就是拿出一个空位置，保存起来，接下来把这个位置前面
的元素和这个位置的值比较；如果大于，就一种元素，如果小于，就结束比较，
保存元素在现在的位置上。
注：java中，用Arrays.sort()排序;java中已经定义好的一种排序方式。
开发中，对数组排序。要使用该句代码。
（4）查找：折半查找
先排序，后折半比较；得到相应的数组的下标值。
import java.util.*;
class ArrayTest2{
//选择排序
public static void selectSort(int[] arr){
//int temp = 0;
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
//temp = arr[i];
//arr[i] = arr[j];
//arr[j] = temp;
swap(arr,i,j);
}
}
}
}
//冒泡排序或者就沉底排序
public static void bubbleSort(int[] arr){
//int temp =0;
for(int i =0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
//temp = arr[i];
//arr[i] = arr[j];
//arr[j] = temp;
swap(arr,j,j+1);
}
}
}
}
//优化后的选择排序
public static void optimizeSort(int[] arr){
int min;
for(int i=0;i<arr.length-1;i++){
min =i;
for(int j=i+1;j<arr.length;j++){
if(arr[min]>arr[j]){
min = j;
}
}
swap(arr,i,min);
}
}
//直接插入排序
public static void insertSort(int[] arr){
for (int i = 1; i < arr.length; i++)
{
//从1角标开始取值，取出一个空位置来
if (arr[i - 1] > arr[i])
{
//一次插入的过程
int temp = arr[i];
int j = i;
//比较移动位置，因为有空位置存在，不会就是元素
while (j > 0 && arr[j - 1] > temp)
{
arr[j] = arr[j - 1];
j--;
}
//放在合适的位置上
arr[j] = temp;
}
}
}
public static void swap(int[] arr,int x,int y){
int temp = 0;
temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
public static void printArray(int[] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1)
System.out.print(arr[i]+", ");
else
System.out.println(arr[i]+" ]");
}
}
public static void main(String[] args){
int[] a = new int[]{3,1,4,9,6,2};
printArray(a);
//selectSort(a);
//printArray(a);
//bubbleSort(a);
//printArray(a);
//optimizeSort(a);
//printArray(a);
insertSort(a);
printArray(a);
//Arrays.sort(a);
//printArray(a);
}
}
（5）删除数组元素的操作
public static void arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length)；
利用System.arraycopy()实现删除数组某个元素的操作。
public class JudgeArrayIsRepeat {
public static int[] judgeInt(int[] a,int x) {
int index = x-1 ;
int[] b = new int[a.length-1];
System.arraycopy(a, 0, b, 0, index);
System.arraycopy(a, index+1, b, index, b.length-index);
// for (int i = 0; i < b.length; i++) {
// System.out.print(b[i]+" ");
// }
return b;
}
public static void main(String[] args){
int[] a = {1,2,3,4,5};
int[] c = null;
c = JudgeArrayIsRepeat.judgeInt(a,3);
for (int i = 0; i < c.length; i++) {
System.out.print(c[i]+" ");
}
}
}
（6）进制转化
a、十进制转二进制:查表法
0 1 -二进制
0 1
b、十进制转八进制：查表法
0 1 2 3 4 5 6 7 -八进制
0 1 2 3 4 5 6 7
c、十进制转十六进制:查表法
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
利用数组的值与下标的对应，将所有临时元素存储起来，建立相应的对应关系。
7、二位数组
（1）默认初始化问题
//Cannot specify an array dimension after an empty dimension
int[][] arrs = new int[][2];//这种定义方式不行
//默认初始化，因为没有初始化一维数组，所以arr[0]引用都是默认值null。
int[][] arr = new int[3][];
System.out.println(arr); //[[I@1db9742
System.out.println(arr[0]);//null
arr[0] = new int[3];
（2）静态初始化的方式
元素类型[][] 数组名 ={{,,},{,,},{,,}}；
8、数组的定义时括号的位置
int[] x; int x[];
int[][] y; int y[][]; int[] y[];
所以
int[] x,y[];//x一维，y二维。
注：写程序时，不要这么定义，容易产生歧义。