Java数组

数组的定义：
　　数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。
数组的基本特点：
1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型，不允许出现混合类型。元素的类型可以是java 支持的任意类型
3. 数组类型可以是任何数据类型，包括基本类型和引用类型。
4. 数组的元素在堆内存中被分配空间，并且是连续分配的
5. 使用new 关键字对数组进行 内存的分配。每个元素都会被jvm 赋予默认值。默认规则：整数：0 浮点数：0.0 字符：\u0000 布尔：false 引用数据类型：null。
6. 数组的元素都是有序号的，序号从0开始，0序的。称作数组的下标、索引、角标
数组的声明：
1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
2. 声明一个数组的时候并没有数组真正被创建。
3. 构造一个数组，必须指定长度。
数组格式：
元素类型[ ] 数组名 = new 元素类型 [元素个数或数组长度];   //  int [] arr = new int [3];
[]：代表这是数组类型。
数组名：一个合法的标识符，命名规范 和 局部变量 规范一致。
new：是java 的关键字。用来向JVM申请内存的。
元素类型[元素个数] ：决定了向JVM申请的内存空间的大小。 
　　　　　　　　　    大小：元素类型字节数 * 元素个数
元素的个数：只要是一个合法的java 表达式就可以。 返回一个int 类型的值即可
example

  
数组的常见问题：

数组的优缺点：
优点：
1：可以保存若干个数据。
2：随机访问的效率很高。根据下标访问元素效率高（元素连续分配空间）。
缺点：
1：数组的元素的类型必须一致。元素类型必须一致。
2：连续分配空间在堆中，如果数组的元素很多，对内存的要求更加的严格。
3：根据内容查找元素效率比较低，需要逐个比较个。
4：删除元素、插入元素效率比较低，需要移动大量的元素。
5：数组定长，不能自动扩容。
6：数组没有封装，数组对象只提供了一个数组长度的属性，但是没有提供方法用来操作元素。
java 提供了一整套的 针对不同需求的 对于容器的解决的方案。集合框架部分。不同的容器有不同的特点，满足不同的需求。数组的缺点都会被干掉。

数组的初始化：静态初始化、动态初始化、默认初始化
静态初始化：int[] arr = { 1, 2, 3 };// 静态初始化基本类型数组；
动态初始化：int[] arr = new int[2];//动态初始化数组，先分配空间；
　　　　　　arr[0]=1;//给数组元素赋值；
　　　　　　arr[1]=2;//给数组元素赋值；
默认初始化：int arr[] = new int[2]; // 默认值：0,0
　　　　　　boolean[] b = new boolean[2]; // 默认值：false,false
　　　　　　String[] s = new String[2]; // 默认值：null, null
数组的遍历：for循环   for-each循环


基于数组的拷贝操作:拷贝、删除、扩容
　　System类里也包含了一个static void arraycopy(object src，int srcpos，object dest， int destpos，int length)方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。




  ArrayCopy Code

1 package com.boom.arrays;
 2 
 3 /**  4  * 关于数组的操作:拷贝，删除，扩容  5  *  6  * @author Administrator  7  *  8 */  9 public class ArrayCopyTest { 10 11 public static void main(String[] args) { 12  arrayCopy(); 13 14 // String[] str = { "Java", "C", "C++", "Python", "JScript" }; 15 // removeElement(str, 1); 16 // 17 // String[] str = { "Java", "C", "C++", "Python", "JScript" }; 18 // extendRange(str); 19 20 21  } 22 23 // 数组的拷贝 24 public static void arrayCopy() { 25 String[] s1 = { "aa", "bb", "cc", "dd", "ee", }; 26 String[] s2 = new String[7]; 27 // 从s1 里下标为1的数组开始拷贝到s2,存放在s2里下标为2的位置开始，拷贝3个数组。 28 System.arraycopy(s1, 1, s2, 2, 3); 29 for (int i = 0; i < s2.length; i++) { 30 System.out.print(s2[i] + " "); 31  } 32  } 33 34 // 删除数组中指定索引的位置,并返回原数组.实则还是拷贝数组，再覆盖原来的数组 35 public static String[] removeElement(String[] s, int index) { 36 System.arraycopy(s, index + 1, s, index, s.length - index - 1); 37 // 特殊处理最后一个数组 38 s[s.length - 1] = null; 39 for (int i = 0; i < s.length; i++) { 40 System.out.print(s[i] + " " + "\n"); 41  } 42 return s; 43  } 44 45 // 数组的扩容 46 public static String[] extendRange(String[] s1){ 47 // 传入的数组基础上空间+3 48 String[] s2 = new String[s1.length+3]; 49 System.arraycopy(s1, 0, s2, 0, s1.length); 50 for(int i = 0; i){ 51  System.out.println(s2[i]); 52  } 53 return s2; 54 55  } 56 57 }

java.util.Arrays类
JDK提供的java.util.Arrays类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了：排序、查找、填充、打印内容等常见的操作。
打印数组  Arrays.toString(arr)

数组元素的排序  Arrays.toString(arr)


二分法查找  Arrays.binarySearch(arr, key)

数组填充


多维数组
　　多维数组可以看成以数组为元素的数组。可以有二维、三维、甚至更多维数组，但是实际开发中用的非常少。最多到二维数组(学习容器后，我们一般使用容器，二维数组用的都很少)。
数组的排序：

 

1 package com.boom0904;
 2 
 3 import java.util.Arrays;  4  5 import javax.sound.sampled.Mixer;  6  7 import com.boom.util.RandomNumber;  8  9 /** 10  * 数组的排序 11  * 12  * @author Administrator 13  * 14 */ 15 public class SortTest { 16 17 public static void main(String[] args) { 18  bubbleSort(); 19 //selectSort(); 20  } 21 22 private static void selectSort() { 23 int arr[] = RandomNumber.createRandomArray(10, 0, 20); 24  System.out.println(Arrays.toString(arr)); 25  selectSort(arr); 26  System.out.println(Arrays.toString(arr)); 27  } 28 29 private static void bubbleSort() { 30 int arr[] = RandomNumber.createRandomArray(10, 0, 20); 31  System.out.println(Arrays.toString(arr)); 32  bubbleSort(arr); 33  System.out.println(Arrays.toString(arr)); 34 35  } 36 37 /** 38  * 冒泡排序 39  * 40  * @param arr 41  * @return 42 */ 43 public static void bubbleSort(int[] arr) { 44 for (int i = 0; i < arr.length - 1; i++) { // 外层循环控制趟数 45 // boolean flag = false; 46 for (int j = 0; j < arr.length - i - 1; j++) { // 内层循环控制一趟 47 // 如果前面的的数大于后面的数，定义最大值为前面的数。再进行位置置换，ASC 48 if (arr[j] > arr[j + 1]) { // arr[j] < arr[j + 1] 反则DESC 49 // flag = true; 50 int temp = arr[j]; 51 arr[j] = arr[j + 1]; 52 arr[j + 1] = temp; 53  } 54  } 55 // if (!flag) { 56 // System.out.println("i==" + i); 57 // break; 58 // } 59  } 60  } 61 62 /** 63  * 选择排序 64  * 65  * @param arr 66 */ 67 public static void selectSort(int[] arr) { 68 // 外层循环控制 选择的趟数 69 // i 既可以控制次数，还代表了当前待排序区的第一个元素的索引 70 for (int i = 0; i < arr.length - 1; i++) { 71 // 用于保存当前最小值的下标 72 int minIndex = i; 73 // 对待排序区查找最小值的索引 74 for (int j = i + 1; j < arr.length; j++) { 75 if (arr[j] < arr[minIndex]) { 76 minIndex = j; 77  } 78  } 79 // 将最小值和 下标是i 的元素交换 80 if (i != minIndex) {// 待排序的第一个元素不是最小的情况 81 int temp = arr[i]; 82 arr[i] = arr[minIndex]; 83 arr[minIndex] = temp; 84  } 85  } 86  } 87 88 }

1 package com.boom0904;
 2 /**
 3  * 数组的查找  4 */  5 import java.util.Arrays;  6  7 import com.boom.util.RandomNumber;  8  9 public class ArithmeticTest { 10 11 public static void main(String[] args) { 12 // test1(); 13  test2(); 14  } 15 16 private static void test2() { 17 int[] arr = RandomNumber.createRandomArray(50, 0, 100); 18  Arrays.sort(arr); 19 int index = binarySearch(arr, 99); 20 System.out.println("index=" + index); 21 if (index != -1) { 22  System.out.println(arr[index]); 23  } 24  } 25 26 private static void test1() { 27 int[] arr = RandomNumber.createRandomArray(10, 0, 20); 28  System.out.println(Arrays.toString(arr)); 29 System.out.println(indexOf(arr, 9)); 30 31  } 32 33 /** 34  * 自定义方法，实现查找指定的数组中是否存在指定的值 时间复杂度：T(n) = O(n) 35  * 36  * @param arr 37  * 被查找的 数组 38  * @param key 39  * 被查找的值 40  * @return 如果 key 在arr 中存在，返回key 的第一个索引，否则返回 -1 41 */ 42 public static int indexOf(int[] arr, int key) { 43 // 处理特殊情况:如果数组为空或者数组的长度为0,返回-1 44 if (arr == null) 45 return -1; 46 int len = arr.length; 47 if (len == 0) 48 return -1; 49 50 for (int i = 0; i < len; i++) { 51 if (arr[i] == key) 52 return i; 53  } 54 return -1; 55  } 56 57 /** 58  * 二分搜索法 59  * 60  * @param arr 61  * 待搜索的数组 62  * @param key 63  * 搜索的值 64  * @return 如果 key 在arr 中存在，返回key 的第一个索引，否则返回 -1 65 */ 66 public static int binarySearch(int[] arr, int key) { 67 // 处理特殊情况:如果数组为空或者数组的长度为0,返回-1 68 if (arr == null) 69 return -1; 70 int len = arr.length; 71 if (len == 0) 72 return -1; 73 int low = 0; 74 int high = len - 1; 75 // 不在区间内 76 if (key < arr[low] || key > arr[high]) 77 return -1; 78 79 int mid = low + high >> 1; 80 int counter = 0; 81 while (high >= low) { 82 counter++; 83 if (arr[mid] == key) { 84 System.out.println("找到了。。。查找次数=" + counter); 85 return mid; 86 } else if (arr[mid] < key) {// 在右边 87 low = mid + 1; 88 } else { // 在左边 89 high = mid - 1; 90  } 91 mid = low + high >> 1; 92  } 93 System.out.println("没找到。。查找次数=" + counter); 94 return -1; 95  } 96 97 }