数组操作大全<Java实现>

/**
 * 数组操作类
 * @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){	
	}
}