Java开发学习 Java数组操作工具
看到网上的一段关于对数组操作的代码，觉得有用，在此备用。
importjava.util.Arrays;
importjava.util.List;
importjava.util.Map;
importjava.util.Random;
importjava.util.TreeMap;
/**
*@desc数组操作工具
*@authorOuyangPeng
*@datatime2013-5-1110:31:02
*
*/
publicclassMyArrayUtils{
/**
*排序算法的分类如下：1.插入排序（直接插入排序、折半插入排序、希尔排序）；2.交换排序（冒泡泡排序、快速排序）；
*3.选择排序（直接选择排序、堆排序）；4.归并排序；5.基数排序。
*
*关于排序方法的选择：(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
*(2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；
*(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。
*
*/
/**
*交换数组中两元素
*
*@since1.1
*@paramints
*需要进行交换操作的数组
*@paramx
*数组中的位置1
*@paramy
*数组中的位置2
*@return交换后的数组
*/
publicstaticint[]swap(int[]ints,intx,inty){
inttemp=ints[x];
ints[x]=ints[y];
ints[y]=temp;
returnints;
}
/**
*冒泡排序方法:相邻两元素进行比较性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4
*冒泡排序（BubbleSort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，
*如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，
*也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
冒泡排序算法的运作如下:
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
*@since1.1
*@paramsource
*需要进行排序操作的数组
*@return排序后的数组
*/
publicstaticint[]bubbleSort(int[]source){
/*for(inti=0;isource[j+1]){//把大的值交换到后面
swap(source,j,j+1);
}
}
}*/
for(inti=source.length-1;i>0;i--){
for(intj=0;jsource[j+1]){
swap(source,j,j+1);
}
}
}
returnsource;
}
/**
*选择排序法方法：选择排序(Selectionsort)是一种简单直观的排序算法，其平均时间复杂度为O(n2)。
*它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，
*再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此类推，直到所有元素均排序完毕。
*性能：选择排序的交换操作介于0和(n-1)次之间，选择排序的比较操作为n(n-1)/2次之间，
*选择排序的赋值操作介于0和3(n-1)次之间，其平均时间复杂度为O(n2)
*交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。
*但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。
*
*@since1.1
*@paramsource
*需要进行排序操作的数组
*@return排序后的数组
*/
publicstaticint[]selectSort(int[]source){
for(inti=0;isource[j]){
swap(source,i,j);
}
}
}
returnsource;
}
/**
*插入排序方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。性能：比较次数O(n^2),n^2/4
*复制次数O(n),n^2/4比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
*
*@since1.1
*@paramsource
*需要进行排序操作的数组
*@return排序后的数组
*/
publicstaticint[]insertSort(int[]source){
for(inti=1;i0)&&(source[j]x){
j--;
}
if(itemp){
high=mid-1;
}else{
low=mid+1;
}
}
for(j=i-1;j>high;j--)
source[j+1]=source[j];
source[high+1]=temp;
}
returnsource;
}
/**
*反转数组
*
*@since1.1
*@paramsource
*需要进行反转操作的数组
*@return反转后的数组
*/
publicstaticint[]reverse(int[]source){
intlength=source.length;
inttemp=0;
for(inti=0;i>1;i++){
temp=source[i];
source[i]=source[length-1-i];
source[length-1-i]=temp;
}
returnsource;
}
/**
*在当前位置插入一个元素,数组中原有元素向后移动;如果插入位置超出原数组，则抛IllegalArgumentException异常
*
*@paramarray
*@paramindex
*@paraminsertNumber
*@return
*/
publicstaticint[]insert(int[]array,intindex,intinsertNumber){
if(array==null||array.length==0){
thrownewIllegalArgumentException();
}
if(index-1>array.length||index<=0){
thrownewIllegalArgumentException();
}
int[]dest=newint[array.length+1];
System.arraycopy(array,0,dest,0,index-1);
dest[index-1]=insertNumber;
System.arraycopy(array,index-1,dest,index,dest.length-index);
returndest;
}
/**
*整形数组中特定位置删除掉一个元素,数组中原有元素向前移动;如果插入位置超出原数组，则抛IllegalArgumentException异常
*
*@paramarray
*@paramindex
*@return
*/
publicstaticint[]remove(int[]array,intindex){
if(array==null||array.length==0){
thrownewIllegalArgumentException();
}
if(index>array.length||index<=0){
thrownewIllegalArgumentException();
}
int[]dest=newint[array.length-1];
System.arraycopy(array,0,dest,0,index-1);
System.arraycopy(array,index,dest,index-1,array.length-index);
returndest;
}
/**
*2个数组合并，形成一个新的数组
*
*@paramarray1
*@paramarray2
*@return
*/
publicstaticint[]merge(int[]array1,int[]array2){
int[]dest=newint[array1.length+array2.length];
System.arraycopy(array1,0,dest,0,array1.length);
System.arraycopy(array2,0,dest,array1.length,array2.length);
returndest;
}
/**
*数组中有n个数据，要将它们顺序循环向后移动k位，即前面的元素向后移动k位，后面的元素则循环向前移k位，
*例如，0、1、2、3、4循环移动3位后为2、3、4、0、1。
*
*@paramarray
*@paramoffset
*@return
*/
publicstaticint[]offsetArray(int[]array,intoffset){
intlength=array.length;
intmoveLength=length-offset;
int[]temp=Arrays.copyOfRange(array,moveLength,length);
System.arraycopy(array,0,array,offset,moveLength);
System.arraycopy(temp,0,array,0,offset);
returnarray;
}
/**
*随机打乱一个数组
*
*@paramlist
*@return
*/
publicstaticListshuffle(Listlist){
java.util.Collections.shuffle(list);
returnlist;
}
/**
*随机打乱一个数组
*
*@paramarray
*@return
*/
publicint[]shuffle(int[]array){
Randomrandom=newRandom();
for(intindex=array.length-1;index>=0;index--){
//从0到index处之间随机取一个值，跟index处的元素交换
exchange(array,random.nextInt(index+1),index);
}
returnarray;
}
//交换位置
privatevoidexchange(int[]array,intp1,intp2){
inttemp=array[p1];
array[p1]=array[p2];
array[p2]=temp;
}
/**
*对两个有序数组进行合并,并将重复的数字将其去掉
*
*@parama
*：已排好序的数组a
*@paramb
*：已排好序的数组b
*@return合并后的排序数组
*/
privatestaticListmergeByList(int[]a,int[]b){
//用于返回的新数组，长度可能不为a,b数组之和，因为可能有重复的数字需要去掉
Listc=newArrayList();
//a数组下标
intaIndex=0;
//b数组下标
intbIndex=0;
//对a、b两数组的值进行比较，并将小的值加到c，并将该数组下标+1，
//如果相等，则将其任意一个加到c，两数组下标均+1
//如果下标超出该数组长度，则退出循环
while(true){
if(aIndex>a.length-1||bIndex>b.length-1){
break;
}
if(a[aIndex]b[bIndex]){
c.add(b[bIndex]);
bIndex++;
}else{
c.add(a[aIndex]);
aIndex++;
bIndex++;
}
}
//将没有超出数组下标的数组其余全部加到数组c中
//如果a数组还有数字没有处理
if(aIndex<=a.length-1){
for(inti=aIndex;i<=a.length-1;i++){
c.add(a[i]);
}
//如果b数组中还有数字没有处理
}elseif(bIndex<=b.length-1){
for(inti=bIndex;i<=b.length-1;i++){
c.add(b[i]);
}
}
returnc;
}
/**
*对两个有序数组进行合并,并将重复的数字将其去掉
*
*@parama
*:已排好序的数组a
*@paramb
*:已排好序的数组b
*@return合并后的排序数组,返回数组的长度=a.length+b.length,不足部分补0
*/
privatestaticint[]mergeByArray(int[]a,int[]b){
int[]c=newint[a.length+b.length];
inti=0,j=0,k=0;
while(imap=sortByTreeMap(a,b);
*Iteratoriterator=map.entrySet().iterator();while
*(iterator.hasNext()){Map.Entrymapentry=
*(Map.Entry)iterator.next();
*System.out.print(mapentry.getValue()+"");}
*/
privatestaticMapmergeByTreeMap(int[]a,int[]b){
Mapmap=newTreeMap();
for(inti=0;i
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。