java数组与集合工具类的使用

java字符串与集合转换工具使用

我们知道在Java 中有几种集合类，比如 List,Set，还有 Map，List集合一般是存放的元素是有序可重复的，Set 存放的元素则是无序不可重复的，而 Map 集合存放的是键值对。

java的不固定参数

不固定参数一定要放到最后一个位置

	/**
	 * 
	 * @param name 姓名参数
	 * @param age 年龄参数
	 * @param hobbies 爱好 个人不固定
	 */
	void speak(String name,int age,String ...hobbies){
		System.out.println("我是"+name+",我今年"+age+"岁了");
		for(String hobby:hobbies){
			System.out.print(hobby+" ");
		}
	}
	
	public static void main(String[] args) {
		Person4 zhangsan=new Person4();
		zhangsan.speak("张三",23,"游泳","唱歌","跳舞");
	}

java.util.Arrays

用来处理数组的各种方法，而且每个方法基本上都是静态方法，能直接通过类名Arrays调用。

asList

 public static  List asList(T... a) {
        return new ArrayList(a);
    }

作用是返回由指定数组支持的固定大小列表。

	/**
	 * 将字符串转换为集合
	 * @param string
	 * @return
	 */
	private static List getList(String string) {
		String[] split = string.split(",");
		List strings = Arrays.asList(split);
		return strings;
	}

我们知道集合中有个上层接口 List，其有个典型实现类 ArrayList

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable

所以我们可以用 instanceof 运算符判断 某个对象是否是 List 接口的实现类，如果是返回 true，否则返回 false

ArrayList arrayList = new ArrayList();
System.out.println(arrayList instanceof List);//true

java判断数组中是否包含某个元素

	String[] orgString = {"2018-01","2018-02","2018-03","2018-04","2018-05","2018-06","2018-07","2018-08","2018-09","2018-10","2018-11","2018-12"};

		for (LeakPointVO leakPointVO : realRushCount) {
			String counts = leakPointVO.getNormalValue();
			String checkDate = leakPointVO.getCheckDate();
			if(!Arrays.asList(orgString).contains(checkDate)||null==checkDate) {
				continue;
			}
			String checkDateName = compareDic(checkDate);
			datelist.add(checkDateName);
			Numlist.add(counts);
		}

返回的 ArrayList 数组是一个定长列表，我们只能对其进行查看或者修改，但是不能进行添加或者删除操作

　　通过源码我们发现该类是没有add()或者remove() 这样的方法的，如果对其进行增加或者删除操作，都会调用其父类 AbstractList 对应的方法，而追溯父类的方法最终会抛出 UnsupportedOperationException 异常。如下：

1 String[] str = {"a","b","c"};
2 List listStr = Arrays.asList(str);
3 listStr.set(1, "e");//可以进行修改
4 System.out.println(listStr.toString());//[a, e, c]
5 listStr.add("a");//添加元素会报错 java.lang.UnsupportedOperationException 

已知数组数据，如何快速获取一个可进行增删改查的列表List

1 String[] str = {"a","b","c"};
2 List listStr = new ArrayList(Arrays.asList(str));
3 listStr.add("d");
4 System.out.println(listStr.size());//4

Arrays.asList() 方法使用场景

　　Arrays工具类提供了一个方法asList, 使用该方法可以将一个变长参数或者数组转换成List 。但是，生成的List的长度是固定的；能够进行修改操作（比如，修改某个位置的元素）；不能执行影响长度的操作（如add、remove等操作），否则会抛出UnsupportedOperationException异常。

　　所以 Arrays.asList 比较适合那些已经有数组数据或者一些元素，而需要快速构建一个List，只用于读取操作，而不进行添加或删除操作的场景。

copyOf

拷贝数组元素。底层采用 System.arraycopy() 实现，这是一个native方法。

  public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

　src:源数组

　　srcPos:源数组要复制的起始位置

　　dest:目的数组

　　destPos:目的数组放置的起始位置

　　length:复制的长度

　　注意：src 和 dest都必须是同类型或者可以进行转换类型的数组。

int[] num1 = {1,2,3};
int[] num2 = new int[3];
System.arraycopy(num1, 0, num2, 0, num1.length);
System.out.println(Arrays.toString(num2));//[1, 2, 3]

    /**
     * @param original 源数组
     * @param newLength //返回新数组的长度
     * @return
     */
    public static int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

deepEquals

是用来比较两个数组的元素是否相等，不过 deepEquals 能够进行比较多维数组，而且是任意层次的嵌套数组。

         String[][] name1 = {{ "G","a","o" },{ "H","u","a","n"},{ "j","i","e"}};  
         String[][] name2 = {{ "G","a","o" },{ "H","u","a","n"},{ "j","i","e"}};
         System.out.println(Arrays.equals(name1,name2));// false  
         System.out.println(Arrays.deepEquals(name1,name2));// true

fill

该系列方法用于给数组赋值，并能指定某个范围赋值。

    //给a数组所有元素赋值 val
    public static void fill(int[] a, int val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }
    
    //给从 fromIndex 开始的下标，toIndex-1结尾的下标都赋值 val,左闭右开
    public static void fill(int[] a, int fromIndex, int toIndex, int val) {
        rangeCheck(a.length, fromIndex, toIndex);//判断范围是否合理
        for (int i = fromIndex; i < toIndex; i++)
            a[i] = val;
    }

toString 用来打印一维数组的元素

 1     public static String toString(int[] a) {
 2         if (a == null)
 3             return "null";
 4         int iMax = a.length - 1;
 5         if (iMax == -1)
 6             return "[]";
 7 
 8         StringBuilder b = new StringBuilder();
 9         b.append('[');
10         for (int i = 0; ; i++) {
11             b.append(a[i]);
12             if (i == iMax)
13                 return b.append(']').toString();
14             b.append(", ");
15         }
16     }

ArrayList

java.util.ArrayList 是一个用数组实现的集合，支持随机访问，元素有序且可以重复

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable

实现 List 接口

这个接口是 List 类集合的上层接口，定义了实现该接口的类都必须要实现的一组方法

我们知道 ArrayList 集合是由数组构成的，那么向 ArrayList 中添加元素，也就是向数组赋值。我们知道一个数组的声明是能确定大小的，而使用 ArrayList 时，好像是能添加任意多个元素，这就涉及到数组的扩容。

扩容的核心方法就是调用Arrays.copyOf 方法，创建一个更大的数组，然后将原数组元素拷贝过去即可。

  public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //添加元素之前，首先要确定集合的大小
        elementData[size++] = e;
        return true;
    }

1 Object[] obj = {null,1};
2 
3 ArrayList list = new ArrayList();
4 list.add(null);
5 list.add(1);
6 System.out.println(list.size());//2

对于 ArrayList 集合添加元素，我们总结一下：

　　①、当通过 ArrayList() 构造一个空集合，初始长度是为0的，第 1 次添加元素，会创建一个长度为10的数组，并将该元素赋值到数组的第一个位置。

　　②、第 2 次添加元素，集合不为空，而且由于集合的长度size+1是小于数组的长度10，所以直接添加元素到数组的第二个位置，不用扩容。

　　③、第 11 次添加元素，此时 size+1 = 11，而数组长度是10，这时候创建一个长度为10+10*0.5 = 15 的数组（扩容1.5倍），然后将原数组元素引用拷贝到新数组。并将第 11 次添加的元素赋值到新数组下标为10的位置。

　　④、第 Integer.MAX_VALUE - 8 = 2147483639，然后 2147483639%1.5=1431655759（这个数是要进行扩容） 次添加元素，为了防止溢出，此时会直接创建一个 1431655759+1 大小的数组，这样一直，每次添加一个元素，都只扩大一个范围。

　　⑤、第 Integer.MAX_VALUE - 7 次添加元素时，创建一个大小为 Integer.MAX_VALUE 的数组，在进行元素添加。

　　⑥、第 Integer.MAX_VALUE + 1 次添加元素时，抛出 OutOfMemoryError 异常。

　　注意：能向集合中添加 null 的，因为数组可以有 null 值存在。

ArrayList这是一个可以放可重复元素的一个集合。其实为什么说ArrayList在添加或者删除上的性能比LinkedList慢，因为在添加或者删除的时候会让数组进行一个拷贝操作，特别是删除的时候，需要对数组进行一个复制或者移动，但还好都是用java的本地方法进行的，在效率上比较高，还要提到的就是另外一个集合Vector，这是一个线程安全的ArrayList，在实现上并没有多大差别，只是在方法上面添加了一个 synchronized

import java.util.ArrayList;

public class test1 {

    public static void main(String[] args) {
        ArrayList list1 =new ArrayList();
        //像动态数组中添加元素
        list1.add("a");
        list1.add("b");
        list1.add("c");
        list1.add("d");
        System.out.println(list1);
        //在指定的位置添加元素
        list1.add(4, "e");
        System.out.println(list1);
        //将一个数组的元素全部添加到另一个数组中
        ArrayList list2 =new ArrayList();
        list2.add("f");
        System.out.println(list2);
        //将数组1中的元素全部添加到数组2中
        list2.addAll(list1);
        System.out.println(list2);
        //获取list2中的第2个元素
        System.out.println("lit2中的第2个元素"+list2.get(1));
        //遍历list2中的所有元素
        for(int i=0;i 0)//size-index-1 > 0 表示 0 0)
23             System.arraycopy(elementData, index+1, elementData, index,
24                              numMoved);
25         elementData[--size] = null; // 
26     }

remove(Object o)方法是删除第一次出现的该元素。然后通过System.arraycopy进行数组自身拷贝。

通过调用 set(int index, E element) 方法在指定索引 index 处的元素替换为 element。并返回原数组的元素。

1     public E set(int index, E element) {
2         rangeCheck(index);//判断索引合法性
3 
4         E oldValue = elementData(index);//获得原数组指定索引的元素
5         elementData[index] = element;//将指定所引处的元素替换为 element
6         return oldValue;//返回原数组索引元素
7     }

通过调用 rangeCheck(index) 来检查索引合法性。

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

当索引为负数时，会抛出 java.lang.ArrayIndexOutOfBoundsException 异常。当索引大于集合长度时，会抛出 IndexOutOfBoundsException 异常。

①、根据索引查找元素

1     public E get(int index) {
2         rangeCheck(index);
3 
4         return elementData(index);
5     }

同理，首先还是判断给定索引的合理性，然后直接返回处于该下标位置的数组元素。

②、根据元素查找索引

 1     public int indexOf(Object o) {
 2         if (o == null) {
 3             for (int i = 0; i < size; i++)
 4                 if (elementData[i]==null)
 5                     return i;
 6         } else {
 7             for (int i = 0; i < size; i++)
 8                 if (o.equals(elementData[i]))
 9                     return i;
10         }
11         return -1;
12     }

注意：indexOf(Object o) 方法是返回第一次出现该元素的下标，如果没有则返回 -1。

还有 lastIndexOf(Object o) 方法是返回最后一次出现该元素的下标。

	public static void main(String[] args) {
		ArrayList arrayList=new ArrayList();
		arrayList.add("张三");
		arrayList.add("李四");
		pringArrayList(arrayList);
		// 将指定的元素插入此列表中的指定位置。
		arrayList.add(1,"小张三");
		pringArrayList(arrayList);
		// 用指定的元素替代此列表中指定位置上的元素。
		arrayList.set(2, "小李四");
		pringArrayList(arrayList);
		// 移除此列表中指定位置上的元素。
		arrayList.remove(0);
		pringArrayList(arrayList);
	}

SubList

1     public List subList(int fromIndex, int toIndex) {
2         subListRangeCheck(fromIndex, toIndex, size);
3         return new SubList(this, 0, fromIndex, toIndex);
4     }

作用是返回从 fromIndex(包括) 开始的下标，到 toIndex(不包括) 结束的下标之间的元素视图。如下：

1 ArrayList list = new ArrayList();
2 list.add("a");
3 list.add("b");
4 list.add("c");
5 
6 List subList = list.subList(0, 1);
7 for(String str : subList){
8     System.out.print(str + " ");//a
9 }

这里出现了 SubList 类，这也是 ArrayList 中的一个内部类。

注意：返回的是原集合的视图，也就是说，如果对 subList 出来的集合进行修改或新增操作，那么原始集合也会发生同样的操作。

 1 ArrayList list = new ArrayList();
 2 list.add("a");
 3 list.add("b");
 4 list.add("c");
 5 
 6 List subList = list.subList(0, 1);
 7 for(String str : subList){
 8     System.out.print(str + " ");//a
 9 }
10 subList.add("d");
11 System.out.println(subList.size());//2
12 System.out.println(list.size());//4,原始集合长度也增加了

想要独立出来一个集合，解决办法如下：

List subList = new ArrayList(list.subList(0, 1));

isEmpty()

1     public boolean isEmpty() {
2         return size == 0;
3     }

	private  String getJoinActivityMembers(ActivityMetting activityMetting)
	{

		List orgUserIds = new ArrayList(Arrays.asList(activityMetting.getOrgUserId().split(",")));

		List joinMembers =  new ArrayList(Arrays.asList(activityMetting.getJoinMembers().split(",")));
		joinMembers.addAll(orgUserIds);
		joinMembers = new ArrayList(new HashSet(joinMembers));
		  List listTemp = new ArrayList();
		    for (int i = 0;i < joinMembers.size(); i++) {
		      if (joinMembers.get(i) != null&&joinMembers.get(i).length()!=0) {
		        listTemp.add(joinMembers.get(i));
		      }
		    }

		if(CollectionUtils.isEmpty(listTemp))
		{
			return "";
		}
		
		String str = String.join(",", listTemp);
		return str;
	}

 LinkedList

这是一个由链表构成的数组，LinkedList 是一个用链表实现的集合，元素有序且可以重复。

1 public class LinkedList
2     extends AbstractSequentialList
3     implements List, Deque, Cloneable, java.io.Serializable

相对于 ArrayList 集合，LinkedList 集合多实现了一个 Deque 接口，这是一个双向队列接口，双向队列就是两端都可以进行增加和删除操作。

　LinkedList 有两个构造函数，第一个是默认的空的构造函数，第二个是将已有元素的集合Collection 的实例添加到 LinkedList 中，调用的是 addAll() 方法

    public LinkedList() {
    }
    public LinkedList(Collection