一维数组
创建一维数组
使用new关键字进行内存 分配
（1）先声明，再用new运算符分配内存
声明：
数组元素类型 数组名字[] 或者
数组元素类型[] 数组名字
分配：
数组名字 = new 数组元素类型[数组元素个数]；
如：
int arr[]; arr = new int[5];
（2）声明的同时分配内存
数组元素类型 数组名[] = new 数组元素类型[数组元素个数]；
如;
int arr[] = new int[5];
初始化一维数组
如：
int arr[] = new int[]{5,6,85,4,7};
或者
int arr[] = {5,6,85,4,7};
public class MyShuzu { public static void main(String[] args) { // TODO 自动生成的方法存根 int day[] = new int[] {31,28,31,30,31,30,31,31,30,31,30,31}; //创建数组day[]并初始化 for(int i = 1; i <= 12; i ++) { System.out.println(i + "月有" + day[i-1] + "天"); //day[i-1]调用数组中每一个元素 } } }
二维数组的声明与创建可参考一维数组
声明：
数组元素类型 数组名字[][] 或者
数组元素类型[][] 数组名字
分配：
（1）对于同一维元素个数相同时可直接为每一维分配内存，如：
a = new int[2][4];
（2）分别为每一维分配内存，如：
a = new int[2][]; a[0] = new int[2]; a[1] = new int[3];
二维数组初始化语法：
type arrayname[][] = {value1,value2...valuen}
如：
int myarr[][] = {{12,0},{45,10}} //int myarr[][]; myarr[0][0] = 12; myarr[0][1] = 0; myarr[1][0] = 45; myarr[1][1] = 10; int a[][] = new int[3][4]; //创建二维数组 for(int i = 0; i < a.length; i++) { for(int j = 0; j < a[i].length; j++) { a[i][j] = i + j; /*初始化数组元素。对于整型二维数组，创建成 功后系统会给数组中每个元素赋予初始值0。*/ System.out.print(a[i][j] + " "); //不换行输出 } System.out.println();//换行 /*0 1 2 3 1 2 3 4 2 3 4 5 */ }
填充替换数组元素
导入java.util.Arrays类,该方法适用于任意类型数组元素的替换，以int型为例
（1）fill(int[] a,int value)
import java.util.Arrays; //导入java.util.Arrays类 public class MyShuzu3 { public static void main(String[] args) { int arr[] = new int[5]; Arrays.fill(arr, 8); //使用同一个值对数组进行填充 for(int i = 0; i < 5; i++) { //遍历循环数组中的元素 System.out.println("第" + i +"个元素是:" + arr[i]); } } }
（2）fill(int[] a, int fromIndex, int toIndex, int value)
将指定的int值分配给int型数组指定范围的每一个元素。
Arrays.fill(arr, 2, 5, 6); //替换2（包含）~5（不包含）的值为6 for(int i = 0; i < 5; i++) { //遍历循环数组中的元素 System.out.println("第" + i +"个元素是:" + arr[i]); }
对数组排序
Arrays类中的静态sort()方法可实现对数组的排序。可对任意类型数组进行升序排序，按照字典（万国码）编排顺序。
import java.util.Arrays; //导入java.util.Arrays类 public class MyShuzu4 { public static void main(String[] args) { // TODO 自动生成的方法存根 int a[] = {23,42,5,9}; //声明数组 Arrays.sort(a); //将数组排序 for(int i = 0; i < a.length; i++) { System.out.println(a[i]); } } }
复制数组
（1）copyOf(arr, int newlength)
（2）copyOfRange(arr, int fromIndex, int toIndex)
int a1[] = Arrays.copyOf(a, 5); //复制数组a[]至指定长度，超出长度用0填充 for(int i = 0; i < a1.length; i++) { System.out.println(a1[i]); } System.out.println(); int a2[] = Arrays.copyOfRange(a, 1, 4); //复制数组a[]指定长度 for(int i = 0; i < a2.length; i++) { System.out.println(a2[i]); }
数组查询
binarySearch()方法，使用二分搜索法（故需先使用sort()来排序）搜索指定数组，以获得指定对象。
（1）binarySearch(Object[] a, Object key)
若key包含在数组中，返还搜索值的索引；否则返还-1或“-”（插入点）。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引（此索引需下标+1，即从1开始的序号列）
（2）binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
若key包含在数组指定范围内，返还搜索值的索引；否则返还-1或“-”（插入点）。此插入点或此key若比指定范围最小值还小，则插入点取指定范围的最小值的索引（+1，即从1开始的序号列）；此插入点或此key若比指定范围最大值还大，则插入点取指定范围的最大值后一位的索引（+1，即从1开始的序号列）；
若插入点在指定范围内则同（1）。
import java.util.Arrays; public class MyShuzuChaxun { public static void main(String[] args) { // TODO 自动生成的方法存根 String str[] = new String[] {"ab","cd","ef","gh","yz"}; //声明字符串数组 Arrays.sort(str); //对str[]排序 int index = Arrays.binarySearch(str, "cd"); //查询str[]中的"cd"的索引位置 System.out.println(index); //输出索引,1 System.out.println(); int index1 = Arrays.binarySearch(str, 1, 3, "ab"); System.out.println(index1); //输出索引,-2 System.out.println(); int arr[] = {4,25,10}; Arrays.sort(arr); int index2 = Arrays.binarySearch(arr, 0, 1, 8); System.out.println(index2); //-2 int a[] = {4, 5, 6, 8, 12, 32 ,45 ,58 ,245 }; //已排序好的数组 int index3 = Arrays.binarySearch(a, 2, 5, 5); //此key比指定范围最小值还小 System.out.println(index3); //-3 int index4 = Arrays.binarySearch(a, 2, 5, 7); //插入点在指定范围内 System.out.println(index4); //-4 int index5 = Arrays.binarySearch(a, 2, 5, 9); //插入点在指定范围内 System.out.println(index5); //-5 int index6 = Arrays.binarySearch(a, 2, 5, 13); //插入点比指定范围最大值还大 System.out.println(index6); //-6 int index7 = Arrays.binarySearch(a, 2, 5, 58); //key比指定范围最大值还大 System.out.println(index7); //-6 int index8 = Arrays.binarySearch(a, 2, 5, 123); //插入点比指定范围最大值还大 System.out.println(index8); //-6 } }
冒泡排序
主要思想：比较俩相邻元素，若满足一定条件（如判断大小、日期前后等）则进行交换，每次循环都将最大（或最小）排到最后，下一次循环是对数组中其他元素进行类似操作。
双层循环：外层循环控制排序轮数，一般为排序数组长度-1次；内层循环用于对比数组中每个邻近元素大小以确定是否交换位置，对比和交换次数随排序轮数增加而减少。
如：
//以下的程序输出均为：<1<3<4<15<24<63 public class MyBubbleSort { public static void main(String[] args) { // TODO 自动生成的方法存根 int arr[] = {63,4,24,1,3,15}; MyBubbleSort sorter = new MyBubbleSort(); //创建冒泡排序类的对象 sorter.sort(arr); //调用冒泡排序方法 } /*冒泡排序 * * @param arr *要排序的数组 */ public void sort(int arr[]) { for(int i = 1; i < arr.length; i++) { for(int j = 0; j < arr.length - i; j++) { if(arr[j] > arr[j+1]) { int temp = arr[j]; //把第一个元素值保存在临时变量中 arr[j] = arr[j+1]; //把第二个元素值保存在第一个元素单元中 arr[j+1] = temp; //把临时变量保存在第二个元素单元中 }else; } } show(arr); } //显示数组所有元素 public void show(int arr[]) { for(int x : arr) { System.out.print("<" + x); } } }
或者采用创建静态方法
import java.util.Arrays; public class MyShuzu1 { public static void main(String[] args) { // TODO 自动生成的方法存根 int arr[] = {63,4,24,1,3,15}; Arrays.sort(arr); //调用排序方法 show(arr); //调用静态输出方法 } //显示数组所有元素 public static void show(int arr[]) { //创建静态方法输出 for(int x : arr) { System.out.print("<" + x); } } }
创建静态方法与非静态方法的区别主要在于内存的释放，静态方法会在整个程序执行过程中占用内存，而非静态只有在调用方法时在占用内存。
直接选择排序
基本思想：将指定排序位置与其他数组元素分别比较，若满足条件则交换元素值。
算法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序地放在已排好序的数列的最后，直到全部待排序的数据元素排完。
如：
public class MyShuzu1 { public static void main(String[] args) { // TODO 自动生成的方法存根 int arr[] = {63,4,24,1,3,15}; MyShuzu1 sort = new MyShuzu1(); //创建排序类的对象 sort.sorter(arr); //调用排序对象的方法 } //创建直接选择排序方法 public void sorter(int arr[]) { int index; //定义位置变量 for(int i = 1; i < arr.length; i ++) { index = 0; //每一轮的位置变量index初始化 for(int j = 1; j <= arr.length - i; j ++) { if(arr[j] > arr[index]) { //判断当前index位置是比其他元素小 index = j; //将index位置改为比他大的元素位置 }else; } //找出按序列相应位置相应值后再交换 int temp = arr[arr.length - i]; arr[arr.length - i] = arr[index]; arr[index] = temp; } show(arr); } //显示数组所有元素 public void show(int arr[]) { //创建静态方法输出 for(int x : arr) { System.out.print("<" + x); } } }
或者
/*此程序实现的功能和MyShuzu1同为直接选择排序 * 只是此程序思路更为复杂，不建议 */ public class MyShuzu1_1 { public static void main(String[] args) { // TODO 自动生成的方法存根 int arr[] = {63,4,24,1,3,15}; MyShuzu1 sort = new MyShuzu1(); //创建排序类的对象 sort.sorter(arr); //调用排序对象的方法 } //创建直接选择排序方法 public void sorter(int arr[]) { int index; //定义位置变量 for(int i = 1; i < arr.length; i ++) { index = i - 1; //每一轮的位置变量index初始化 for(int j = i; j < arr.length; j ++) { if(arr[j] < arr[index]) { //判断当前index位置是比其他元素大 index = j; //将index位置改为比他小的元素位置 //位置1 }else; //位置2 } //找出按序列相应位置相应值后再交换 int temp = arr[i - 1]; arr[i - 1] = arr[index]; arr[index] = temp; /*命名为“交换语句”。“交换语句”也可在位置1及位置2， *只是这样交换的次数就和冒泡排序一样多了 */ } show(arr); } //显示数组所有元素 public void show(int arr[]) { //创建静态方法输出 for(int x : arr) { System.out.print("<" + x); } } }
反转排序
以相反的顺序将原有的数组内容重新排列
反转语句：
for(int i = 0; i < arr.length - 1 - i; i ++) { int temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp;
注意：数组下标是从0开始的，最后一个元素的表示总是“数组名[length-1]”。
import
浙公网安备 33010602011771号