數組操作大全

/**
 * 數組操作類
 * @author Sking
 */

import java.util.LinkedHashSet;
import java.util.Set;

public class ArrayUtils {
	
	/**1.複製數組*/
	//System.arraycopy(from,fromIndex,to,toIndex,count);
	
	//Xxx代表long,int,short,char,byte,double,float,object,返回Xxx[]數組
	//Arrays.copyof(Xxx[] a,int len)
	//Arrays.copyOfRange(Xxx[] a,int from,int to)
	
	/**2.數組升序快速排序*/
	//Xxx代表long,int,short,char,byte,double,float,Object(實現Comparable接口)，返回類型爲void
	//Arrays.sort(Xxx a[]);
	//Arrays.sort(Xxx a[],int fromIndex,int toIndex)；
	
	//自定義函數，將數組從中間位置向兩邊排序展開
	/**
	 * 將指定數組從中間位置向兩邊排序展開，先左後右
	 * @param input 待排序數組
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void sort(Comparable[] input){
		int n=input.length;
		Comparable[] output=new Comparable[n];
		int middle=n/2;
		Comparable[] temp=input;
		for(int i=n;i>1;i--){
			int maxPos=0;
			for(int j=0;j<i;j++)
				if(temp[j].compareTo(temp[maxPos])>0)
					maxPos=j;
			swap(temp,maxPos,i-1);
		}//將temp數組降序排序
		output[middle]=temp[0];//存放最大的元素
		int left=n/2-1;//左邊指針
		int right=n/2+1;//右邊指針
			for(int k=1;k<n;k+=2)
				output[left--]=temp[k];
			for(int m=2;m<n;m+=2)
				output[right++]=temp[m];
			System.arraycopy(output, 0, input, 0, n);
	}
	
	private static void swap(Object[] a,int i,int j){
		Object temp;
		temp=a[i];
		a[i]=a[j];
		a[j]=temp;	
	}
   

	/**3.數組二分查找*/
	//Xxx表示long,int,short,char,byte,double,float,object(實現了Comparable接口),返回索引位置
	//Arrays.binarySearch(Xxx a[],Xxx v)；
	//Arrays.binarySearch(Xxx a[],int from,int to,Xxx v);
	
	/**4.填充數組*/
	//Xxx表示long,int,short,char,byte,double,float,Object,返回類型爲void
	//Arrays.fill(Xxx a[],Xxx v)
	//Arrays.fill(Xxx a[],int from,int to,Xxx v)
	
	/**5.比較數組是否相等
	 * @param <T>*/
	//Xxx表示long,int,short,char,byte,boolean,double,float,Object(實現了Comparable接口)
	//Arrays.equals(Xxx[] a,Xxx[] b)
	
	
	/**
	 * 6.判斷數組元素是否重複,T表示類型參數，
	 *       如果是內置類型使用對應的包裝類。
	 * @param a 輸入數組
	 * @return 如果數組不包含指定重複元素則返回true，否則false
	 */
	public static <T> boolean ArrayUnique(T[] a){
		int len=a.length;
		Set<T> set=new LinkedHashSet<T>();
		for(T t:a)
			set.add(t);
		if(len==set.size())
			return true;
		return false;
	}
	
	
	/**7.打印數組*/
	//Xxx代表long,int,short,char,byte,boolean,double,float,Object
	//打印格式爲：[元素1,元素2,元素3...]
	//Arrays.toString(Xxx[] a)
	
	//字符數組轉換爲字符串
	//String.copyValueOf(char[] data[,int offset,int count])
	//String.valueOf(char[] data[, int offset, int count])
	
	//自定義函數，使用指定的分割標誌符鏈接數組爲字符串
	/**
	 * 使用指定的分割標誌鏈接數組爲字符串,
	 *       如果未指定分隔符則默認使用逗號。
	 * @param a 待鏈接數組
	 * @param separator 分割標誌符，沒有設置則使用逗號
	 * @return  使用指定的分割標誌鏈接數組得到的字符串
	 */
	public static <T> String ArrayToString(T[] a,String separator){
		separator=(separator==null?",":separator);
		StringBuffer sb=new StringBuffer();
		for(T t:a)
			sb.append(t.toString()).append(separator);
		sb.delete(sb.lastIndexOf(separator), sb.length());
		return sb.toString();
	}
	
	/**8.反轉數組*/
	//自定義反轉數組函數
	/**
	 * 反轉指定數組
	 * @param a 待反轉數組
	 */
	public static <T> void ArrayReverse(T[] a){
		int len=a.length;
		for(int i=0,j=len-1;i<j;i++,j--){
			T temp=a[i];
			a[i]=a[j];
			a[j]=temp;
		}
	}
	
	/**9.求數組最值*/
	//見編程問題--數組問題--數組最值.java
	
	/**10.一維數組最大字段和問題*/
	//見編程問題--數組問題--一維最大字段和.java
	
	/**11.指定索引插入元素*/
	//自定義函數：實現指定索引插入元素到數組中
	/**
	 * 指定索引插入元素到數組中
	 * @param a 指定數組
	 * @param value 待插入元素
	 * @param index 新元素插入位置索引
	 * @return 插入後的新數組
	 * @throws Exception 索引不合法
	 */
	public static Object[] ArrayInsert(Object[] a,Object value,int index) throws Exception{
		if(index<0||index>a.length)
			throw new Exception("索引不合法!");
		Object[] result=new Object[a.length+1];
		System.arraycopy(a, 0, result, 0, index);
		result[index]=value;
		System.arraycopy(a, index, result, index+1,a.length-index);
		return result;
	}
	
	/**12.指定索引刪除元素*/
	//自定義函數：實現指定索引刪除元素並返回刪除後的數組
	/**
	 * 指定索引刪除元素並返回刪除後的數組
	 * @param a 指定數組
	 * @param index 待刪除元素的索引
	 * @return 刪除後的數組
	 * @throws Exception 索引不合法
	 */
	public static Object[] ArrayDelete(Object[] a,int index)throws Exception{
		if(index<0||index>=a.length)
			throw new Exception("索引不合法!");
		Object[] result=new Object[a.length-1];
		System.arraycopy(a, 0, result, 0, index);
		System.arraycopy(a, index+1, result, index, a.length-index-1);
		return result;
	}
	
	
	public static void main(String[] args){	
	}
}