知识大全 自己编写的Java数组操作工具
Posted 元素
篇首语：如果梦想有捷径的话，那么这条路的名字一定叫坚持。本文由小常识网(cha138.com)小编为大家整理，主要介绍了知识大全 自己编写的Java数组操作工具相关的知识，希望对你有一定的参考价值。
自己编写的Java数组操作工具 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！
看到网上的一段关于对数组操作的代码 觉得有用 在此备用 [java]
import java util ArrayList;
import java util Arrays;
import java util List;
import java util Map;
import java util Random;
import java util TreeMap;
/**
* @desc 数组操作工具
* @author OuyangPeng
* @datatime : :
*
*/
public class MyArrayUtils
/**
* 排序算法的分类如下 插入排序(直接插入排序 折半插入排序 希尔排序); 交换排序(冒泡泡排序 快速排序);
* 选择排序(直接选择排序 堆排序); 归并排序; 基数排序
*
* 关于排序方法的选择 ( )若n较小(如n≤ ) 可采用直接插入或直接选择排序
* ( )若文件初始状态基本有序(指正序) 则应选用直接插人 冒泡或随机的快速排序为宜;
* ( )若n较大 则应采用时间复杂度为O(nlgn)的排序方法 快速排序 堆排序或归并排序
*
*/
/**
* 交换数组中两元素
*
* @since
* @param ints
* 需要进行交换操作的数组
* @param x
* 数组中的位置
* @param y
* 数组中的位置
* @return 交换后的数组
*/
public static int[] swap(int[] ints int x int y)
int temp = ints[x];
ints[x] = ints[y];
ints[y] = temp;
return ints;
/**
* 冒泡排序方法:相邻两元素进行比较 性能 比较次数O(n^ ) n^ / ;交换次数O(n^ ) n^ /
* 冒泡排序(Bubble Sort)是一种简单的排序算法 它重复地走访过要排序的数列 一次比较两个元素
* 如果他们的顺序错误就把他们交换过来 走访数列的工作是重复地进行直到没有再需要交换
* 也就是说该数列已经排序完成 这个算法的名字由来是因为越小的元素会经由交换慢慢 浮 到数列的顶端
冒泡排序算法的运作如下:
比较相邻的元素 如果第一个比第二个大 就交换他们两个
对每一对相邻元素作同样的工作 从开始第一对到结尾的最后一对 在这一点 最后的元素应该会是最大的数
针对所有的元素重复以上的步骤 除了最后一个
持续每次对越来越少的元素重复上面的步骤 直到没有任何一对数字需要比较
* @since
* @param source
* 需要进行排序操作的数组
* @return 排序后的数组
*/
public static int[] bubbleSort(int[] source)
/*for (int i = ; i < source length ; i++) // 最多做n 趟排序
for (int j = ; j < source length i ; j++) // 对当前无序区间score[ length i ]进行排序(j的范围很关键 这个范围是在逐步缩小的)
if (source[j] > source[j + ]) // 把大的值交换到后面
swap(source j j + );
*/
for (int i = source length ; i> ; i )
for (int j = ; j < i; j++)
if (source[j] > source[j + ])
swap(source j j + );
return source;
/**
* 选择排序法 方法 选择排序(Selection sort)是一种简单直观的排序算法 其平均时间复杂度为O(n )
* 它的工作原理如下 首先在未排序序列中找到最小元素 存放到排序序列的起始位置 然后
* 再从剩余未排序元素中继续寻找最小元素 然后放到排序序列末尾 以此类推 直到所有元素均排序完毕
* 性能 选择排序的交换操作介于 和(n )次之间 选择排序的比较操作为n(n )/ 次之间
* 选择排序的赋值操作介于 和 (n )次之间 其平均时间复杂度为O(n )
* 交换次数比冒泡排序少多了 由于交换所需CPU时间比比较所需的CUP时间多 所以选择排序比冒泡排序快
* 但是N比较大时 比较所需的CPU时间占主要地位 所以这时的性能和冒泡排序差不太多 但毫无疑问肯定要快些
*
* @since
* @param source
* 需要进行排序操作的数组
* @return 排序后的数组
*/
public static int[] selectSort(int[] source)
for (int i = ; i < source length; i++)
for (int j = i + ; j < source length; j++)
if (source[i] > source[j])
swap(source i j);
return source;
/**
* 插入排序 方法 将一个记录插入到已排好序的有序表(有可能是空表)中 从而得到一个新的记录数增 的有序表 性能 比较次数O(n^ ) n^ /
* 复制次数O(n) n^ / 比较次数是前两者的一般 而复制所需的CPU时间较交换少 所以性能上比冒泡排序提高一倍多 而比选择排序也要快
*
* @since
* @param source
* 需要进行排序操作的数组
* @return 排序后的数组
*/
public static int[] insertSort(int[] source)
for (int i = ; i < source length; i++)
for (int j = i; (j > ) && (source[j] < source[j ]); j )
swap(source j j );
return source;
/**
* 快速排序 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub lists) 步骤为
* 从数列中挑出一个元素 称为 基准 (pivot)
* 重新排序数列 所有元素比基准值小的摆放在基准前面 所有元素比基准值大的摆在基准的后面
* (相同的数可以到任一边) 在这个分割之后 该基准是它的最后位置 这个称为分割(partition)操作
* 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序
* 递回的最底部情形 是数列的大小是零或一 也就是永远都已经被排序好了
* 虽然一直递回下去 但是这个算法总会结束 因为在每次的迭代(iteration)中 它至少会把一个元素摆到它最后的位置去
*
* @since
* @param source
* 需要进行排序操作的数组
* @return 排序后的数组
*/
public static int[] quickSort(int[] source)
return qsort(source source length );
/**
* 快速排序的具体实现 排正序
*
* @since
* @param source
* 需要进行排序操作的数组
* @param low
* 开始低位
* @param high
* 结束高位
* @return 排序后的数组
*/
private static int[] qsort(int source[] int low int high)
int i j x;
if (low < high)
i = low;
j = high;
x = source[i];
while (i < j)
while (i < j && source[j] > x)
j ;
if (i < j)
source[i] = source[j];
i++;
while (i < j && source[i] < x)
i++;
if (i < j)
source[j] = source[i];
j ;
source[i] = x;
qsort(source low i );
qsort(source i + high);
return source;
// /////////////////////////////////////////////
// 排序算法结束
// ////////////////////////////////////////////
/**
* 二分法查找 查找线性表必须是有序列表
*
* @since
* @param source
* 需要进行查找操作的数组
* @return 需要查找的值在数组中的位置 若未查到则返回
*/
public static int[] binarySearch(int[] source)
int i j;
int low high mid;
int temp;
for (i = ; i < source length; i++)
temp=source[i];
low= ;
high=i ;
while (low <= high)
mid = (low + high)/ ;
if (source[mid]>temp)
high=mid ;
else
low = mid + ;
for (j= i ; j>high;j )
source[j+ ]=source[j];
source[high+ ]=temp;
return source;
/**
* 反转数组
*
* @since
* @param source
* 需要进行反转操作的数组
* @return 反转后的数组
*/
public static int[] reverse(int[] source)
int length = source length;
int temp = ;
for (int i = ; i < length >> ; i++)
temp = source[i];
source[i] = source[length i];
source[length i] = temp;
return source;
/**
* 在当前位置插入一个元素 数组中原有元素向后移动; 如果插入位置超出原数组 则抛IllegalArgumentException异常
*
* @param array
* @param index
* @param insertNumber
* @return
*/
public static int[] insert(int[] array int index int insertNumber)
if (array == null || array length == )
throw new IllegalArgumentException();
if (index > array length || index <= )
throw new IllegalArgumentException();
int[] dest = new int[array length + ];
System arraycopy(array dest index );
dest[index ] = insertNumber;
System arraycopy(array index dest index dest length index);
return dest;
/**
* 整形数组中特定位置删除掉一个元素 数组中原有元素向前移动; 如果插入位置超出原数组 则抛IllegalArgumentException异常
*
* @param array
* @param index
* @return
*/
public static int[] remove(int[] array int index)
if (array == null || array length == )
throw new IllegalArgumentException();
if (index > array length || index <= )
throw new IllegalArgumentException();
int[] dest = new int[array length ];
System arraycopy(array dest index );
System arraycopy(array index dest index array length index);
return dest;
/**
* 个数组合并 形成一个新的数组
*
* @param array
* @param array
* @return
*/
public static int[] merge(int[] array int[] array )
int[] dest = new int[array length + array length];
System arraycopy(array dest array length);
System arraycopy(array dest array length array length);
return dest;
/**
* 数组中有n个数据 要将它们顺序循环向后移动k位 即前面的元素向后移动k位 后面的元素则循环向前移k位
* 例如 循环移动 位后为
*
* @param array
* @param offset
* @return
*/
public static int[] offsetArray(int[] array int offset)
int length = array length;
int moveLength = length offset;
int[] temp = pyOfRange(array moveLength length);
System arraycopy(array array offset moveLength);
System arraycopy(temp array offset);
return array;
/**
* 随机打乱一个数组
*
* @param list
* @return
*/
public static List shuffle(List list)
java util Collections shuffle(list);
return list;
/**
* 随机打乱一个数组
*
* @param array
* @return
*/
public int[] shuffle(int[] array)
Random random = new Random();
for (int index = array length ; index >= ; index )
// 从 到index处之间随机取一个值 跟index处的元素交换
exchange(array random nextInt(index + ) index);
return array;
// 交换位置
private void exchange(int[] array int p int p )
int temp = array[p ];
array[p ] = array[p ];
array[p ] = temp;
/**
* 对两个有序数组进行合并 并将重复的数字将其去掉
*
* @param a
* 已排好序的数组a
* @param b
* 已排好序的数组b
* @return 合并后的排序数组
*/
private static List mergeByList(int[] a int[] b)
// 用于返回的新数组 长度可能不为a b数组之和 因为可能有重复的数字需要去掉
List c = new ArrayList();
// a数组下标
int aIndex = ;
// b数组下标
int bIndex = ;
// 对a b两数组的值进行比较 并将小的值加到c 并将该数组下标+
// 如果相等 则将其任意一个加到c 两数组下标均+
// 如果下标超出该数组长度 则退出循环
while (true)
if (aIndex > a length || bIndex > b length )
break;
if (a[aIndex] < b[bIndex])
c add(a[aIndex]);
aIndex++;
else if (a[aIndex] > b[bIndex])
c add(b[bIndex]);
bIndex++;
else
c add(a[aIndex]);
aIndex++;
bIndex++;
// 将没有超出数组下标的数组其余全部加到数组c中
// 如果a数组还有数字没有处理
if (aIndex <= a length )
for (int i = aIndex; i <= a length ; i++)
c add(a[i]);
// 如果b数组中还有数字没有处理
else if (bIndex <= b length )
for (int i = bIndex; i <= b length ; i++)
c add(b[i]);
return c;
/**
* 对两个有序数组进行合并 并将重复的数字将其去掉
*
* @param a
* :已排好序的数组a
* @param b
* :已排好序的数组b
* @return合并后的排序数组 返回数组的长度=a length + b length 不足部分补
*/
private static int[] mergeByArray(int[] a int[] b)
int[] c = new int[a length + b length];
int i = j = k = ;
while (i < a length && j < b length)
if (a[i] <= b[j])
if (a[i] == b[j])
j++;
else
c[k] = a[i];
i++;
k++;
else
c[k] = b[j];
j++;
k++;
while (i < a length)
c[k] = a[i];
k++;
i++;
while (j < b length)
c[k] = b[j];
j++;
k++;
return c;
/**
* 对两个有序数组进行合并 并将重复的数字将其去掉
*
* @param a
* 可以是没有排序的数组
* @param b
* 可以是没有排序的数组
* @return合并后的排序数组 打印时可以这样 Map map=sortByTreeMap(a b);
* Iterator iterator = map entrySet(erator(); while
* (iterator hasNext()) Map Entry mapentry =
* (Map Entry)iterator next();
* System out print(mapentry getValue()+ );
*/
private static Map mergeByTreeMap(int[] a int[] b)
Map map = new TreeMap();
for (int i = ; i < a length; i++)
map put(a[i] a[i]);
for (int i = ; i < b length; i++)
map put(b[i] b[i]);
return map;
/**
* 在控制台打印数组 之间用逗号隔开 调试时用
*
* @param array
*/
public static String print(int[] array)
StringBuffer sb = new StringBuffer();
for (int i = ; i < array length; i++)
sb append( + array[i]);
System out println( \\n +sb toString() substring( ));
return sb toString() substring( );
cha138/Article/program/Java/hx/201311/26760
相关参考
Java删除数组中重复的元素 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！ 我是将数组封装为类的
Java中数组的返回 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！ 假定我们现在想写一个方法同时
Java中数组的转型和范型 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！ 今天写代码遇到一个奇怪
怎样用Jvm处理Java数组 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！ 记得vamcily曾
Java静态与动态数组特点分析 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！ 平常我们接触到的大
分析Java集合框架及数组的排序 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！ &nbs
使用Java编写的B*算法 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！ 使用Java编写的B*
有时候我们需要将读取文件的内容到一个byte[]数组中然后对这个数组进行一些修改这时我们可以借助于ByteArrayOutputStream这个类来实现 ByteArrayOutputStrea
Java进阶:Java编写通过代理访问的应用程序 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！
SQLServer编写存储过程小工具 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！ 在开发数据库