集合

最新推荐文章于 2024-08-13 21:45:00 发布

Polaris_Qing

最新推荐文章于 2024-08-13 21:45:00 发布

阅读量331

点赞数

CC 4.0 BY-SA版权

分类专栏： java

本文链接：https://blog.youkuaiyun.com/Polaris_Qing/article/details/98509250

java 专栏收录该内容

8 篇文章

订阅专栏

集合框架

》集合：数据集合（用来存储数据的集合）
1：为什么需要学习java中的集合框架？
	数组可以用来存储数据，但有较大的弊端：
		1）数据只能存储相同数据类型的有序集合
		2）数组存储数据时，需要指定当前数组的长度且长度不可变（定长）
		3）不满足需求：由于在大多数的应用场景中，数据都是动态的，使用数组容易导致浪费空间和效率；
		
2：java提供了一套功能强大的集合框架，用来存储数据信息。

3：为什么java提供了这么多集合对象存储数据信息？
		针对不同的需求场景，采用的集合对象也要不同，就本质而言，不同的集合对象底层存储实现方案不同，
	存储结构也不同，适用于不同的需求；

》集合框架的知识点：一张图、3个知识点、6个接口、9个常用类

在这里插入图片描述

迭代器

*Iterable：是java.lang包下的接口，实现该接口能作为foreach的目标
*Iterator：是java.util包下的接口，是一个迭代器，用来迭代当前集合对象
*listIterator:是一个接口，这个接口可以支持并发修改，内部提供了add、set、remove等方法；


*Tips:
	Iterator是一个接口，ArrayList中通过内部类完成对于该接口的实现，其实获取的实现类对象
	如果对于一个list集合对象要通过使用迭代器做修改（删除、添加、修改），那么请使用listIterator方法；

package com.mage.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test02 {
	public static void main(String[] args) {
		//创建集合对象
		Collection co = new ArrayList();
		//添加元素
		co.add("String");
		co.add("Scanner");
		co.add("Integer");
		co.add("InputStream");
		
		//迭代元素
		System.out.println("foreach循环迭代");
		for(Object oj:co) {
			String str = (String)oj;
			System.out.println(str);
		}
		
		System.out.println("Interator 迭代器");
		Iterator it = co.iterator();//实现类对象
		while(it.hasNext()) {
			//获取元素
			System.out.println(it.next());
		}
		
		System.out.println("迭代器的变种写法");
		for(Iterator it1 = co.iterator();it1.hasNext();) {
			System.out.println(it1.next());
		}
	}

}

Collection

》定义：（接口）
	public interface Collection<E> extends Iterable<E>
	<E>	——>	Object
	Iterable：接口，凡是继承或实现Iterable的类，都只能作为foreach的目标；

》存储元素的特点：
	无序、可重复，对于所有的集合框架中的对象，只能存储引用类型
》常见方法：
	add、addAll、remove、removeAll、clear、retainAll、size、isEmpty、contains、containsAll、
	iterator
》迭代方法：
	*普通for循环
	*增强for循环
	*iterator()
	
》tips:没有修改元素方法
》JDK1.9之后，接口的变化：
	只没有构造器，非静态方法一定是私有的，用来服务default方法

添加元素

add(object)：添加元素，返回boolean值；
addAll(Collection)：添加一个集合；

删除元素

clear():清空当前集合所有元素；
remove(object):移除集合中的一个指定元素；返回boolean值；
removeAll(COllection):移除当前集合与指定集合的交集中所有的元素；
retainAll(Collection):保留交集，移除其余元素；

查看元素

isEmpty():查看当前集合是否为null，返回boolean值；
size():查看当前集合元素的个数，返回int值；
contains(Object):查看当前集合是否包含该元素，返回boolean值；

package com.mage.collection;

import java.util.ArrayList;
import java.util.Collection;

public class Test01 {
	public static void main(String[] args) {
		//接口指向实现类对象
		Collection co = new ArrayList();
		
		//添加元素
		co.add("Demo");
		co.add(1);
		
		//添加元素
		Collection col   = new ArrayList();
		col.add("java");
		col.add("Spring");
		
		System.out.println("将col添加到co中："+co.addAll(col));
		
		//删除元素
		col.clear();
		System.out.println("移除不存在的元素："+co.remove("spring"));
		System.out.println(co.removeAll(col));
		
		System.out.println("co中的元素："+co);
		System.out.println(co.retainAll(col));
		System.out.println("co中的元素："+co);
		
		//查看元素
		System.out.println("查看当前集合是否为空："+co.isEmpty());
		System.out.println("查看当前集合元素个数："+co.size());
		System.out.println("查看当前集合是否包含元素："+co.contains("1"));
	}

}

List

（接口）可重复，有序，可以是null值
》定义：public interface Collection<E> extends Collection<E>
		<E>——>	object
》常见方法：
	*增加：add(index,object)、add(object)、addAll(Collection)、add(index,Collection)
	*删除：remove(index/object)、clear()、removeAll(Collection)、retainAll(Collection)
	*修改：set(index,object)
	*查看：indexOf(object)、lastvalueOf(object)、subList(startIndex,endIndex)、
			isEmpty()、size()、get(index)、contain(Object)、containAll(Collection)
》迭代方法：
	*普通for循环
	*增强for循环
	*iterator()
	*listIterator()

添加元素

*add(Object):
	添加元素到当前集合，返回boolean值；
*add(index,Object):
	在当前集合的指定索引（index）上添加元素；返回boolean值；
*addAll(Collection):
	将括号中的集合添加到当前集合的末尾中，返回boolean值；
*addAll(index,Collection):
	将括号中的集合添加当前集合指定索引位置上（index），返回boolean值；

//*例子：
	List list = new ArrayList();
	list.add("javaSE");
	list.add(0,"JavaME");
	Collection col = new Collection();
	Col.add("javaEE");
	list.add(col);
	list.add(0,col);
	System.out.println(list);

删除元素

*remove(Object):
	删除列表中第一次出现的指定元素，返回boolean值
*remove(index):
	删除列表中指定位置上的元素，返回boolean值
*removeAll(Collection):
	删除列表中指定集合中的所有元素，返回boolean值
*retainsAll(Collection):
	保留当前列表与指定集合的交集，并删除其余所有元素；

//例子：
	List list = new ArrayList();
	list.add("javaSE");
	list.add(0,"JavaME");
	Collection col = new Collection();
	Col.add("javaEE");
	list.add(col);
	list.add(0,col);
	System.out.println(list);
	list.remove("JavaME");
	list.remove(0);
	list.remove(col);

查看元素

isEmpty():
	查看当前列表是否为null，返回boolean值；
size():
	查看当前列表中的元素个数，返回int值；
contains(Object):
	查看当前列表是否包含指定元素，返回boolean值；
containsAll(Collection):
	查看当前列表是否包含指定集合中所有元素，返回boolean值；
indexOf(Object):
	查看当前列表是否包含指定元素，并返回该元素的索引（int值）,不包含返回-1；
lastIndexOf(Object):
	查看当前列表是否包含指定元素，返回该元素最后出现的索引（int值），不包含返回-1；
subList(startIndex,endIndex):
	从当前列表startIndex处开始截取，一直到endIndex处，并将截取的所有元素放入一个集合（列表）中去；

//例子：
	List list = new ArrayList();
	list.add("javaSE");
	list.add(0,"JavaME");
	Collection col = new Collection();
	Col.add("javaEE");
	list.add(col);
	list.add(0,col);
	System.out.println(list);
	System.out.println(list.isEmpty());
	System.out.println(list.size());
	System.out.println(list.contains("javaEE"));
	System.out.println(list.contains(col));
	System.out.println(list.indexOf("javaEE"));
	System.out.println(list.lastIndexOf("javaEE"));

修改元素

*set(index,object):
	使用指定元素替换掉当前列表中指定索引上的元素；

例子：
	List list = new ArrayList();
	list.add("javaSE");
	list.add(0,"JavaME");
	Collection col = new Collection();
	Col.add("javaEE");
	list.set(0,"JDK")；
	System.out.println(list);

package com.mage.list;

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

public class Test01 {

	public Test01() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		//创建对象
		List ls = new ArrayList();
		
		//添加元素
		ls.add("javaME");
		ls.add(0,"javaSE");
		ls.add("javaME");
		ls.add(1);
		
		//删除元素
		ls.remove(1);
		ls.remove(Integer.valueOf(1));//int object
		
		//修改
		ls.set(0,"憨宝");
		
		//查看元素
		System.out.println("为null判定："+ls.isEmpty());
		Object obj = ls.get(0);
		System.out.println("查看指定位置上的元素："+obj);
		System.out.println("ls");
		
		List newls = ls.subList(0, 1);
		System.out.println(newls);
		
		System.out.println("查询指定元素的索引："+ls.indexOf(2));
		System.out.println("查询指定元素最后出现的的索引"+ls.lastIndexOf("憨宝"));
		System.out.println("元素的个数："+ls.size());
	}
}

迭代方法

普通for循环、增强for循环（不支持并发修改）、迭代器（iterator[不能支持并发修改]、listIterator[支持并发修改]）

package com.mage.list;

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

public class Test02 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("计算机组成原理");
		list.add("计算机安全技术");
		list.add("操作系统");
		list.add("信息安全技术");
		System.out.println(list);
		
		ListIterator iterator = list.listIterator();
		while(iterator.hasNext()) {
			if("计算机安全技术".equals(iterator.next())) {
				iterator.add("线性代数");
			}
		}
		System.out.println(list);
	}
}

逆序迭代

package com.mage.list;

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

public class Test03 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("计算机组成原理");
		list.add("计算机安全技术");
		list.add("操作系统");
		list.add("信息安全技术");
		System.out.println(list);
		
		System.out.println("正序迭代");
		ListIterator iterator  = list.listIterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		
		
		System.out.println("逆序迭代");
		while(iterator.hasPrevious()) {
			System.out.println(iterator.previous());
		}
	}
}

泛型

》什么是泛型？
	广泛的类型，也是一种数据类型，该数据类型可以为任意类型，在编写过程中不能确定该类型，创建对象时可以指定泛型的类型
》泛型是编译期行为，只能在编译期有效，如果程序跨过编译期，那泛型就没有任何意义
》泛型类：
	定义：
		在类名后加<>，括号中只能写字符，长度不定
		但一般情况下，我们通过大写的26个字母去声明当前泛型
		T ——> type	E ——> element
	使用：
		jdk1.7之后支持泛型的类型推断
		泛型类<具体类型> 变量名 = new 泛型类<>();
		
》泛型接口：
	实现类实现泛型接口时，不能指定泛型类型，创建实现类对象时可以指定泛型类型
	class UserServiceImpl implements UserService<String>

》泛型方法
	在方法中使用泛型的方法
	静态方法无法使用泛型类中声明的泛型类型，因为泛型类型是在创建对象时确定的，而静态方法先于对象存在，如需使用泛型，在当前静态方法上声明泛型类型
	public static <泛型类型> void 方法名(){}

ArrayList

（实现类）扩容2倍；
底层：数组
优缺点：通过索引获取元素以及迭代元素速度较快，但是添加、删除速度很慢
》常见方法：
	*增加：add(index,object)、add(object)、addAll(Collection)、add(index,Collection)
	*删除：remove(index/object)、clear()、removeAll(Collection)、retainAll(Collection)
	*修改：set(index,object)
	*查看：indexOf(object)、lastvalueOf(object)、subList(startIndex,endIndex)、
			isEmpty()、size()、get(index)、contain(Object)、containAll(Collection)
》迭代方法：
	*普通for循环
	*增强for循环
	*iterator()
	*listIterator()

package com.mage.list;

import java.util.ArrayList;
import java.util.Iterator;

public class Test04 {
	public static void main(String[] args) {
		//创建对象
		ArrayList<String> slist = new ArrayList();
		
		//添加元素
		slist.add("电子管计算机");
		slist.add("晶体管计算机");
		slist.add("中小型集成电路计算机");
		slist.add("超大型集成电路计算机");
		
		slist.remove(2);
		System.out.println(slist);
		System.out.println("普通for循环");
		for(int i = 0;i<slist.size();i++) {
			System.out.println(slist.get(i));
		}
		
		System.out.println("增强for循环");
		for(String str:slist) {
			System.out.println(str);
		}
		
		System.out.println("迭代器");
		for(Iterator<String> it = slist.iterator();it.hasNext();) {
			System.out.println(it.next());
		}	
	}
}

LinkedList

实现类
底层：双向链表
优缺点：通过索引获取元素以及迭代元素速度较快，但添加、删除元素很慢
常见方法：和List相同，但多了一些针对头尾的操作
		查看：getFirst()、getLast()、element()、peek()、peekFirst()、peekLast()、
		删除：poll()、pollFirst()、removeFirst()、removeLast()
		添加：offer()、offerFirst()、offerLast()、addFirst()、addLast()
迭代方式：*普通for循环
		*增强for循环
		*iterator()
		*listIterator()

package com.mage.list;

import java.util.LinkedList;

public class Test05 {

	public static void main(String[] args) {
		//创建对象
		LinkedList<String> llist = new LinkedList<>();
		
		//添加元素
		llist.add("刘备");
		llist.add("关羽");
		llist.addFirst("曹操");
		llist.addLast("张飞");
		System.out.println(llist.offer("诸葛亮"));
		System.out.println(llist.offerFirst("郭嘉"));
		System.out.println(llist.offerLast("孙策"));
		System.out.println(llist);
		
		System.out.println(llist.element());//获取头元素
		System.out.println(llist.getFirst());
		System.out.println(llist.getLast());
		
		System.out.println(llist.peek());//获取头元素
		System.out.println(llist.peekFirst());
		System.out.println(llist.peekLast());
	}
}

Vectory

底层：数组（扩容时，1.5倍）
优缺点：线程安全，但速度慢

Set

（接口）无序唯一
定义:public interface Set<E> extends Collection<E>
常见方法：
	添加：add()、addAll()、
	删除：clear()、remove()、removeAll()、retainsAll()
	查看:contains()、containsAll()、size()、isEmpty()、
迭代方法：
	foreach、迭代器

添加元素

add(object)：添加元素，返回boolean值；
addAll(Collection)：添加一个集合；

删除元素

clear():清空当前集合所有元素；
remove(object):移除集合中的一个指定元素；返回boolean值；
removeAll(COllection):移除当前集合与指定集合的交集中所有的元素；
retainAll(Collection):保留交集，移除其余元素；

查看元素

isEmpty():查看当前集合是否为null，返回boolean值；
size():查看当前集合元素的个数，返回int值；
contains(Object):查看当前集合是否包含该元素，返回boolean值；

HashSet

（实现类）底层：数组+链表
优缺点：对元素进行添加、删除、修改效率都很高
常见方法：
	添加：add()、addAll()
	删除：remove()、removeAll()、clear()、retainsAll()
	查看：size()、isEmpty()、contains()、containsAll()
迭代方法：
	foreach、迭代器
注意事项：HashSet存储自定义对象时，一定要重写hashCode()和equals()方法

package com.mage.set;

import java.util.HashSet;


/**
 * 		HashSet存储自定义对象
 * */
public class Test01 {
	public static void main(String[] args) {
		//创建对象
		HashSet<User> hs = new HashSet<>();
		hs.add(new User(13800,"干将莫邪"));
		hs.add(new User(13800,"曹操"));
		hs.add(new User(13800,"干将莫邪"));
		System.out.println(hs);
	}
}

class User{
	private int money;
	private String name;
	
	public User() {
		
	}
	
	public User(int money,String name) {
		super();
		this.money = money;
		this.name = name;
	}
	
	public int getMoney() {
		return money;
	}
	
	public void setMoney(int money) {
		this.money = money;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime*result + money;
		result = prime*result + ((name == null) ? 0 :name.hashCode());
		return result;
	}
	
	@Override
	public boolean equals(Object obj) {
		if(this == obj) {
			return true;
		}
		if(obj == null) {
			return false;
		}
		if(getClass() != obj.getClass()) {
			return false;
		}
		User other = (User)obj;
		if(money != other.money) {
			return false;
		}
		if(name == null) {
			if(other.name == null) {
				return false;
			}	
		}else if(!name.equals(other.name)) {
			return false;
		}
		return true;
	}
}

TreeSet

实现类
底层：树（红黑树/二叉树/平衡树）
优缺点：
	*维护数据的大小（有序），
	*添加速度和删除速度高于ArrayList，低于其他集合；
	*查询速度高于List，低于HashSet；
	*如果对于存储的数据有排序的要求，那么首选TreeSet
常见方法：
	添加元素：add()、addAll()、
	删除元素：clear()、remove()、removeAll()、retainsAll()、
	查找元素：contains()、containsAll()、size()、isEmpty()、
	相较于其他集合多了一些针对排序元素的操作：
		first()、last()、floor()、ceiling()、higher()、lower()
迭代方法：foreach()、(迭代器)iterator()
注意事项：
	如果存储的元素需要按照指定的需求进行排序，创建TreeSet对象时，指定比较器
如果存在的元素自定义对象：
	*要么自定义对象的所属类，实现内部比较器Comparable接口并重写compare方法
	*要么创建TreeSet对象时，指定外部比较器Comparetor并重写compareTo方法

package com.mage.treeset;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSet01 {
	public static void main(String[] args) {
		TreeSet<String> treeSet = new TreeSet<>();
		
		//添加元素
		treeSet.add("oracle");
		treeSet.add("java");
		treeSet.add("php");
		treeSet.add("Mysql");
		
		System.out.println(treeSet);
		
		//查找
		System.out.println("查找当前集合中大于等于给定元素的最小元素:"+treeSet.ceiling("SQLservice"));
		System.out.println("查找当前集合中大于给定元素的最小元素:"+treeSet.higher("SQLservice"));
		
		System.out.println("获取当前集合中最小元素:"+treeSet.first());
		System.out.println("获取当前集合中最大元素:"+treeSet.last());
		
		System.out.println("查找当前集合中小于等于给定元素的最大元素:"+treeSet.floor("SQLservice"));
		System.out.println("查找当前集合中小于给定元素的最大元素:"+treeSet.lower("SQLservice"));
		
		//迭代元素
		for(String str : treeSet) {
			System.out.println(str);
		}
		
		Iterator it = treeSet.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

}

比较器

外部比较器

java.util.Compartor接口指定的；
如果要使用内部比较器，需要实现该接口并重写compare方法
自定义排序规则，可以随着业务扩展随时变化

package com.mage.treeset;

import java.util.Comparator;
import java.util.TreeSet;

public class Test02 {
	public static void main(String[] args) {
		MyCom m = new MyCom();
		
		//传入一个比较器
		TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
			@Override
			public int compare (String str1,String str2) {
				return str1.length() - str2.length();
			}
		});
        
        //lamd表达式
		TreeSet<String> treeSet = new TreeSet<>((str1,str2)->(str1.length()-str2.length()));
		
		//添加元素
		treeSet.add("oracle");
		treeSet.add("java");
		treeSet.add("php");
		treeSet.add("Mysql");
				
		System.out.println(treeSet);
		
	}
}

class MyCom implements Comparator<String>{
	@Override
	public int compare(String str1,String str2) {
		return str1.length()-str2.length();
	}
}

内部比较器

java.lang.Comparable接口定义的；
如果要使用内部比较器，需要实现该接口并重写compareTo方法
不利于后期扩展

Map

（接口）
数据存储方式：K-V 键值方式存储
K：唯一、无序（相当于Set）
V：无序可重复（相当于Collection）
常见方法：
	put(k,v)、get(k)、containsKey(k)、keySet();
	remove(k)、size()、containsValue(v)、values();
	
迭代方法：
	*获取键（K），迭代键的过程中通过get方法获取值（V）;
	for(Object key:keySet()){
        System.out.println(key+"="+map.get(key));
	}
	
	*获取Enter对象，通过getKey和getValue获取键和值
	//获取Entry对象
	Set<entry<String,String>> kvs = map.entrySet();
	//返回一个set集合，该集合中的每个元素都是entry对象
	//实际是HashSet中的Node对象，因为Node实现了Map中的Entry接口
	for(Entry<String,String> entry:kvs){
        System.out.println(entry.getKey()+"=="+entry.getValue);
	}

HashMap

实现类
计算key值；
底层：数组+链表？（jdk1.8后变成树）
优缺点：添加、删除、修改元素的效率都很高
Tips：存储自定义对象作为键时，要保证当前自定义类重写hashCode()和equals()方法
		当前两个对象的属性相同时，我们觉得是同一个对象时，一定要重写

package com.mage.map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Test01 {
	public static void main(String[] args) {
		//创建map对象
		Map<String,String> mps = new HashMap<>();
		
		//put 	 如果存在对应的值，添加的值会覆盖之前的值，并返回之前的值
		mps.put("橘右京","橘子");
		mps.put("宫本武藏","超级兵");
		mps.put("庄周","鱼");
		
		System.out.println(mps.put("庄周", "鲲"));
		System.out.println(mps);
		System.out.println(mps.remove("宫本武藏"));
		System.out.println(mps.remove("庄周", "鲲"));
		System.out.println(mps.size());
		System.out.println("获取对应的值："+mps.get("橘右京"));
		//如果键不存在，返回null
		System.out.println("查看键是否存在："+mps.containsKey("橘右京"));
		System.out.println("查看键是否存在："+mps.containsValue("橘子"));
		
		
		//迭代元素
		System.out.println("迭代所有的键key");
		Set<String> keys = mps.keySet();
		for(String str :keys) {
			System.out.println(str);
		}
		
		System.out.println("迭代所有的值value");
		Collection<String> col = mps.values();
		for(String str : col ) {
			System.out.println(str);
		}
		
		System.out.println("迭代所有元素");
		Set<Entry<String,String>> kvs = mps.entrySet();
		for(Entry<String,String> entry : kvs) {
			System.out.println(entry.getKey()+"==="+entry.getValue());
			
		}
	}
}

TreeMap

实现类
计算key值，
底层：红黑树
优缺点：维护数据的大小（有序），
		添加速度和删除速度高于ArrayList，比其他的集合都低，
		查询速度高于List低于Hash
Tips:如果对于存储的的元素有排序的要求，那首选TreeMap。
		如果存储的元素按照指定的需求进行排序，创建TreeMap对象时，指定比较器。
如果存在的元素是自定义对象：
	1：要么自定义对象所属的类，实现内部比较器Comparable接口，并重写compareTo方法；
	2：要么创建TreeMap对象时，指定外部比较器Comparator接口，并重写compare方法；

package com.mage.map;

import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Test01 {
	public static void main(String[] args) {
		TreeMap<String,Integer> tm = new TreeMap<>();
		
		tm.put("王者荣耀",90);
		tm.put("和平精英",90);
		tm.put("穿越火线",90);
		tm.put("炉石传说", 90);
		System.out.println("tm");
		
		System.out.println("查找大于或等于指定元素的最小元素："+tm.ceilingKey("口袋妖怪"));
		System.out.println("查找大于指定元素的最小元素："+tm.ceilingEntry("刺激战场"));
		
		Set<String> sets = tm.keySet();
		for(String str : sets) {
			System.out.println(str+"=="+tm.get(str));
		}
		
		Set<Entry<String,Integer>> et = tm.entrySet();
		for(Entry<String,Integer> ets : et) {
			System.out.println(ets.getKey()+"=="+ets.getValue());
		}
	}
}

Collections

思考class、interface、方法、变量分别能使用什么修饰符？
 
 	Collections通过一组方法	aynchronizedXXXX(XXXX)
	该组方法可以针对传入的集合对象，做线程同步，返回能够同步的线程安全的集合对象			
 	不一定是线程安全的，及其特殊的情况会发生问题。

解决办法：
 	concurrent包下的同步集合实现，同步集合在jdk1.8之后采用分段锁机制完成对于数据的加锁操作
 	
单例模式：
public static Single getInstance(){
 	if(single==null){
  		single = new Single();
	}
 	return sigle;
}

package com.mage.common;

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

public class Test01 {
	public static void main(String[] args) {
		//使用Collections
		List<String> list = new ArrayList<>();
		Collections .sort(list);
		
		//添加元素到集合中
		Collections.addAll(list, "a","b","d","e");
		
		//使用binarySearch查找元素，一定要先排序，返回的是排序之后的元素索引位置
		System.out.println(Collections.binarySearch(list,"d"));
		System.out.println(list);
		
		//对于集合中的元素进行排序
		Collections.sort(list);
		System.out.println(Collections.binarySearch(list,"d"));
		System.out.println(list);
		
		//打乱集合中元素的顺序
		Collections.shuffle(list);
		System.out.println(list);
        //反转列表中元素的顺序
		Collections.reverse(list);
		System.out.println(list);	
	}
}

Arrays

Arrays.asList返回的是Arrays类中的内部类ArrayList，而这个类的对象是不允许添加以及删除元素的，也就是返回的集合对象是一个长度不可变得ArrayList。
toArray ->集合转数组
asList ->数组转集合

package com.mage.common;

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

public class Test02 {
	public static void main(String[] args) {
		String[] strs = new String[] {"java","php","python","mysql"};
		List<String> ls = Arrays.asList(strs);
		System.out.println("list");
		
		//查找 sort(),fill(),copy(),copyRange(),toString()
		Arrays.sort(strs);
		System.out.println(Arrays.toString(strs));
		System.out.println(Arrays.binarySearch(strs,"java"));
		
		//将指定元素填充到列表中（替换全部元素）
		Arrays.fill(strs,"oracle");
		System.out.println(Arrays.toString(strs));
		
		//复制当前列表到一个新的列表中
		String[] str = Arrays.copyOf(strs,strs.length);
		System.out.println(Arrays.toString(str));
		//从当前列表指定位置开始复制元素一直到指定位置结束（不包括），将复制的元素用一个新数组接收
		str = Arrays.copyOfRange(strs, 1, 2);
		System.out.println(Arrays.toString(str));
		
		List<String> lists = new ArrayList<>();
		Object[] objs = lists.toArray();
		System.out.println(Arrays.toString(objs));
		
	}
}

ray ->集合转数组
asList ->数组转集合


```java
package com.mage.common;

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

public class Test02 {
	public static void main(String[] args) {
		String[] strs = new String[] {"java","php","python","mysql"};
		List<String> ls = Arrays.asList(strs);
		System.out.println("list");
		
		//查找 sort(),fill(),copy(),copyRange(),toString()
		Arrays.sort(strs);
		System.out.println(Arrays.toString(strs));
		System.out.println(Arrays.binarySearch(strs,"java"));
		
		//将指定元素填充到列表中（替换全部元素）
		Arrays.fill(strs,"oracle");
		System.out.println(Arrays.toString(strs));
		
		//复制当前列表到一个新的列表中
		String[] str = Arrays.copyOf(strs,strs.length);
		System.out.println(Arrays.toString(str));
		//从当前列表指定位置开始复制元素一直到指定位置结束（不包括），将复制的元素用一个新数组接收
		str = Arrays.copyOfRange(strs, 1, 2);
		System.out.println(Arrays.toString(str));
		
		List<String> lists = new ArrayList<>();
		Object[] objs = lists.toArray();
		System.out.println(Arrays.toString(objs));
		
	}
}