java数组常用的方法

原创 2013年12月04日 09:59:15

关于java中数组常用的方法

 

package hb.array;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class ArratUtils {

	/**
	 * 将数组的内容显示出来
	 * @param array
	 * @return
	 */
	public static String arrayToStr(int[]array){
		if(array==null||array.length==0){
			return "";
		}
		StringBuffer sb = new StringBuffer();
		sb.append("[");
		for(int i=0;i<array.length;i++){
			sb.append(array[i]);
			if(i<array.length-1){
				sb.append(",");
			}
		}
		sb.append("]");
		return sb.toString();
	}
	@Test
	public void testArrayToStr(){
		int[] a = new int []{1,2,3,4,5,6};
		System.out.println(arrayToStr(a));
	}
	@Test
	public void testArrayToStr2(){
		int[] a = new int []{99,939,32,1,2,324,3,4,5,6};
		String result = java.util.Arrays.toString(a);
		System.out.println(result);
	}
	
	/**
	 * 对传入的数组排序
	 * @param arr
	 * @return
	 */
	public static int[] sortIntArray(int[]arr){
		java.util.Arrays.sort(arr);
		return arr;
	}
	@Test
	public void testSortIntArray(){
		int[] a = new int []{99,939,32,1,2,324,3,4,5,6};
		a = sortIntArray(a);
		System.out.println(arrayToStr(a));
	}
	
	/**
	 * 将ArrayList对象转换为数组对象
	 * @param list
	 * @return
	 */
	public static Object[] arrayListToArray(ArrayList list){
		return list.toArray();
	}
	@Test
	public void testArrayListToString(){
		ArrayList<Integer> list = new ArrayList<Integer>();
		for(int i = 0; i < 9; i++){
			list.add(new Integer(i));
		}
		Object[] a = arrayListToArray(list);
		for(int m=0;m<a.length;m++){
			System.out.println(a[m].toString());
		}
	}
	
//	public static List arrayToList(Object[] o){
//		
//		return java.util.Arrays.asList(o);
//	}
//	@Test
//	public void test(){
//		Integer a[] = new Integer[]{3,4,5,6};
//		List l = arrayToList(a);
//	}
	
	/**
	 * 取数组为int类型的公共部分,即获得两个数组的交集
	 * @param firstArray
	 * @param secondeArray
	 * @return
	 */
	public static int[] intArrayIntersect(int[]firstArray,int[]secondeArray){
		int[] result = null;
		ArrayList list = new ArrayList();
		if(firstArray==null || secondeArray==null){
			return null;
		}
		int temp=0;
		for(int i = 0; i< firstArray.length; i++){
			temp = firstArray[i];
			for(int j = 0; j< secondeArray.length; j++){
				if(temp==secondeArray[j]){
					list.add(temp);
				}
			}
		}
		
		if(list != null && list.size()>0){
			result = new int[list.size()];
			for(int k = 0; k < list.size(); k++){
				result[k]=(Integer)list.get(k);
			}
		}
		return result;
	}
	@Test
	public void testIntArrayIntersect(){
		//初始化数据的两种方式
		int a[] = new int[]{3,4,5,6};
		int b[] = new int[6];
		for(int i=0;i<6;i++){
			b[i]=i;
		}
		String result = arrayToStr(intArrayIntersect(a,b));
		System.out.println(result);
	}
	
	/**
	 * 数组是int类型,取两个数组的并集
	 * @param firstArray
	 * @param secondArray
	 * @return
	 */
	public static int[] intArrayUnit(int[] firstArray,int[] secondArray){
		//先判断两个传入的参数是否有Null
		if(firstArray==null)	return secondArray;
		if(secondArray==null)	return firstArray;
		
		int[] result = null;
		ArrayList list = new ArrayList();
		for(int i=0;i<firstArray.length;i++){
			list.add(firstArray[i]);
		}
		int temp;
		for(int n=0;n<secondArray.length;n++){
			temp = secondArray[n];
			int j=0;
			int length = firstArray.length;
			for(;j<length;j++){
				if(temp==firstArray[j]){
					break;
				}
			}
			if(j==length){
				list.add(temp);
			}
		}
		
		if(list!=null && list.size()>0){
			int listSize = list.size();
			result = new int[listSize];
			for(int m = 0; m < listSize; m++){
				result[m]=(Integer)list.get(m);
			}
		}
		return result;
	}
	@Test
	public void testIntArrayUnit(){
		//初始化数据的两种方式
		int a[] = new int[]{3,4,5,6};
		int b[] = new int[6];
		for(int i=0;i<6;i++){
			b[i]=i;
		}
		String result = arrayToStr(intArrayUnit(a,b));
		System.out.println(result);
	}
	
	/**
	 * 判断主数组中是否含有子数组
	 * @param pArray 主数组
	 * @param sArray 子数组
	 * @return
	 */
	public static boolean isHasElement(int[] pArray, int[] sArray){
		boolean result = true;
		if(pArray==null || sArray.length < 0 || sArray.length>pArray.length){
			return false;
		}
		for(int i=0;i<sArray.length;i++){
			int temp = sArray[i];
			int n=0;
			boolean flag = false;
			for(;n<pArray.length;n++){
				//如果当前值存在于父数组中,则标记为true,否则为false
				if(temp==pArray[n]){
					flag = true;
					break;
				}
			}
			//如果有一个值不在父数组中,则标记结果就是false,推出最外层循环
			if(!flag){
				result = false;
				break;
			}
		}
		return result;
	}
	@Test
	public void testisHasElement(){
		int a[] = new int[]{3,4,5,6};
		int b[] = new int[6];
		for(int i=0;i<6;i++){
			b[i]=i;
		}
		int parent[] = new int[]{5,6,7,8,9,99};
		int son[] = new int[]{6,7,8};
		System.out.println(isHasElement(a,b));
		System.out.println(isHasElement(parent,son));
		System.out.println(isHasElement(son,parent));
		System.out.println(isHasElement(son,son));
		System.out.println(isHasElement(new int[8],son));
		System.out.println(isHasElement(parent,new int[1]));
	}
	
	/**
	 * 取子数组以外的内容
	 * @param parent
	 * @param son
	 * @return
	 */
	public static int[] intArraySonOther(int[] parent,int[] son){
		int[] result = null;
		if(isHasElement(parent,son)){
			ArrayList list = new ArrayList();
			for(int i=0;i<parent.length;i++){
				int temp = parent[i];
				int n=0;
				boolean flag=true;
				for(;n<son.length;n++){
					if(temp == son[n]){
						flag = false;
						break;
					}
				}
				if(flag){
					list.add(temp);
				}
			}
			if(list!=null || list.size()>0){
				result = new int[list.size()];
				for(int k = 0; k < list.size(); k++){
					result[k] = (Integer)list.get(k);
				}
			}
		}
		return result;
	}
	@Test
	public void testIntArraySonOther(){
		int parent[] = new int[]{5,6,7,8,9,99};
		int son[] = new int[]{6,7,8};
		int[] result = intArraySonOther(parent,son);
		System.out.println(arrayToStr(result));
	}
	
	
	/**
	 * 取出在第一个数组中出现过在第二个数组中没出现过的元素
	 * @param firstArray
	 * @param secondArray
	 * @return
	 */
	public static int[] intArrayExceptent(int[] firstArray,int[] secondArray){
		//先取出两个表的交集
		int[] arr = intArrayIntersect(firstArray,secondArray);
		int[] temp = intArraySonOther(firstArray,arr);
		return temp;
	}
	@Test
	public void testIntArrayExceptent(){
		int parent[] = new int[]{5,6,7,8,9,99};
		int son[] = new int[]{6,7,8,66};
		int[] result = intArrayExceptent(parent,son);
//		int[] result = intArrayExceptent(son,parent);
		String str = java.util.Arrays.toString(result);
		System.out.println(str);
	}
}
 

 

 

相关文章推荐

Java数组的几种常用操作方法(排序算法及查找)

数组的查找查找是在数组中寻找特定元素的过程。线性查找法线性查找法将要查找的关键字key与数组中的元素逐个进行比较。如果匹配成功,线性查找法则返回与关键字匹配的元素在数组中的下标;如果没有匹配成功,则返...
  • jxq1994
  • jxq1994
  • 2016年07月27日 18:36
  • 1451

java基础--常用数组的一些操作方法-查找-最值-排序

下面是本人自己学习的时候写的一下数组常用的操作方法!仅供参考 class ArrayTool { private ArrayTool(){} //获取数组最大值 public static ...

编写学习的java几种常用数组的排序方法,给大家分享一下

package sort; //冒泡排序 /*冒泡排序算法的运作如下:(从后往前) 1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 2. 从第一个元素一直比较到最后一个元素。 3. 针对...

JAVA数组常用方法

虽然与数组相比,容器能够自动调整自己的尺寸大小,但是其效率远低于数组。数组是一种效率最高的存储和随机访问对象引用序列的方式。JAVA的类库java.util.Arrays提供了诸多操作数组的方法,在此...

java数组常用方法

数组常用的10个方法

java 运用数组常用的几种排序方法

java中几种常用的排序算法一 在我所应用的过程当中,最主要的是冒泡排序、选择排序、插入排序以及快速排序,下面我来给大家介绍一下,如果有什么不对的地方,希望大家能给我指出来。 1、冒泡排...

Java_数组定义及常用方法

Java_数组定义及常用方法 摘要:        从数组的一些简单介绍、到定义、声明、初始化、以及常用的方法、细微的区别、但是没有讲多维数组、多维数组本质是一维数组的延伸、以后有...

java用数组模拟实现ArrayList以及一些常用方法实现

package com.yys.student; /** * Created by yys on 2017/5/4. */ public class SxtArrayList { pri...

Java中数组常用方法的总结

Java 中数组常用方法的总结   一 、 Java 标 准 类 库 提 供 static 方 法 System.arraycopy(), 用 它 复 制 数 ...

Java数组常用的十个方法

粘的几个数组的用法http://www.csdn.net/article/2013-09-16/2816947-methods-for-java-arrays 0.  声明一个数组(Decl...
  • zygzzp
  • zygzzp
  • 2013年09月20日 20:47
  • 964
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java数组常用的方法
举报原因:
原因补充:

(最多只允许输入30个字)