JAVA集合的区别，常用的方法、遍历、迭代器、泛型

常用的集合类型有，List Set Map

list和set表面最简单的区别是：

          list 有序集合，有索引，可以出现重复的元素

          set 无序集合，无索引，不能出现重复的元素

集合泛型：

    List<String> list3 = new ArrayList<>();

    上面这个代码中 <String>就是泛型。泛型可以确定数据的类型，不至于在程序后面出现各种类型的错误。

说明：java中泛型是一个伪泛型，只是在编译的时候存在，编译后的class文件没有泛型，这么做是为了保证程序的安全。

迭代器：

                //创建三种集合

				List<String> Array = new ArrayList<String>();
				Set<String> set = new HashSet<String>();
				Map<Integer, String>  map = new HashMap<Integer, String>(); 

				//创建集合的迭代器
				Iterator<String> iterator = Array.iterator();
				Iterator<String> iterator2 = set.iterator();
				//Map不能直接迭代，先调用keySet()方法，获得所有key值 放入一个set中
				Set<Integer> keySet = map.keySet();
				Iterator<Integer> iterator3 = keySet.iterator();

				
				//迭代器的两个常用方法
				//如果仍有元素可以迭代，则返回 true。
				iterator.hasNext();
				//返回迭代的下一个元素。
				String next = iterator.next();

List:

list接口常用的子接口有：ArrayList类,LinkedList类

     1)ArrayList的底层是基于动态数组，LinkedList的底层是基于链表来完成的。

     2)基于(1)的存在，所以在使用查找，或者get(int index)(返回此列表中指定位置上的元素。)、
set(int index,E element)(用指定的元素替代此列表中指定位置上的元素。),方法时ArrayList更 有优势，
而在添加，删除的时候，LinkedList更好。(因为数组大小是确定的，所以如果要在ArrayList里面插入元素，
需要进行数组的复制。因为LinkedList是链表，查找元素的时候需要指针慢慢移动，而数组有索引，相对会更快)

     3)但是在实际操作中一般是查找会更多一点所以建议用ArrayList，当然还是以实际情况决定。

//ArrayList&LinkedList的简单的使用，和常用的方法
				//接口多态的方式调用
				List<String> Array1 = new ArrayList<String>();
				List<String> Linked1 = new LinkedList<String>();
				//直接new相对应的集合
				ArrayList<String> Array2 = new ArrayList<String>();
				LinkedList<String> Linked2 = new LinkedList<String>();
				//这两种创建集合的方法建议使用第一种，因为代码的扩展性好一些

				Array1.add("aaa");
				Array1.add("bbb");
				Linked1.add("ccc");
				Linked1.add("ddd");

				System.out.println(Array1);
				System.out.println(Linked1);
				//打印结果
				//[aaa, bbb]
				//[ccc, ddd]
 
				//常用的方法
				//将指定的元素添加到此列表的尾部
				Array1.add("aaa");  
				//将指定的元素添加到指定的位置，第一个index不能超过集合的长度
				Array1.add(2, "ccc");
				//移除此列表中所以的元素，但是集合还存在
				//Array1.clear();
				//查找集合中是否有某个元素，参数是Object类型，有返回true，没有返回false
				boolean aaa = Array1.contains("aaa");
				//返回下标所对应的元素
				String ccc = Array1.get(1);
				//判断集合是否为空
				boolean empty = Array1.isEmpty();
				//删除参数 下标的元素  返回该元素
				String remove = Array1.remove(1);
				//删除集合中 函数参数的元素  返回成功或失败
				boolean remove2 = Array1.remove("aa");
				//返回集合的元素个数
				int size = Array1.size();
				//把集合转化成数组
				Object[] array = Array1.toArray();
				//因为LinkedArray是基于链表实现的
				//所以LinkedArray会有一些对头  和尾操作的方法，详细见API

				//基于Collections接口的方法
				//对集合进行排序，只能对list排序
				Collections.sort(Array1);
				//找到集合中最大的值
				String max = Collections.max(Array1);
				//对集合进行随机排序
				Collections.shuffle(Array1);

Set:

set接口常用的子接口有：Hashset类,Linkedhashset类

     1)hashset由哈希表（实际上是一个HashMap）支持。它不保证存取的顺序一致，可以存null元素。

     2)LinkedHashSet由哈希表和链接列表实现，它可以按照插入的顺序进行迭代（输出）。

     3)set的使用方法和list大同小异就不一一列举了。

Map:

这里主要介绍一个HashMap:

    1)Map里面的val（值）可以相同，但是key（键）不能相同。如果用put()方法添加的时候（list和set添加是用add，而map使用put），如果键值相同了，那么后面的val覆盖了前面的val。

    2)Map里面的key和val都可以为空，但是key只能存一个null（这也和key不能重复相符合）。

    3)当key是Integer类型时，按照数字（key）大小依次输出，key值为null排在第一位。

Map常用方法：

//创建一个HashMap
Map<Integer, String>  map = new HashMap<Integer, String>(); 
//HashMap常使用的方法
//添加一个映射关系（简单理解为向Map里面添加一个值）
map.put(1, "aaa");
map.put(2, "bbb");
map.put(3, "ccc");
//从此映射关系里面移除所有映射(Map依然存在)
map.clear();

//分别查看Map里面是否存在此键，或者此值的映射，返回boolean
boolean containsKey = map.containsKey(1);
boolean containsValue = map.containsValue("aaa");
//用key获得相对应的val，参数是key类型，返回值是val类型
String string = map.get(1);
//判断此Map中是否有 键-值 映射关系，返回boolean
boolean empty2 = map.isEmpty();
//通过key移除对应的映射关系，返回val
String remove3 = map.remove(1);
//返回Map中映射关系数（键值对的个数）
int size2 = map.size();
//返回Map中每个键值对哈希值的和
int hashCode = map.hashCode();
//返回Map中所有的键值，装到一个set集合里面
Set<Integer> keySet = map.keySet();
//返回此映射所包含的映射关系的set视图（API上的说明）
//个人理解：返回一个set，set里面存放Entry对象，Entry里面放的是
//相对应的key，val
Set<Entry<Integer, String>> entrySet2 = map.entrySet();

Map的两种遍历：

//Map两种遍历方法（笔者常使用的两种）
				//方法一：  使用keySet()方法 + 迭代器 iterator()
				//获取存在的所有key
				Set<Integer> keySet2 = map.keySet(); 
				//对存储key的set进行迭代
				Iterator<Integer> iterator3 = keySet2.iterator();
				//使用while循环来遍历
				while(iterator3.hasNext()){
					//取出每一个key
					Integer next = iterator3.next();
					//通过key来取val
					String string2 = map.get(next.intValue());
					System.out.println(next.intValue() +"---"+ string2);
				}
				//使用增强for来遍历
				for (Integer integer : keySet2) {
					String string3 = map.get(integer.intValue());
					System.out.println(integer.intValue() +"---"+ string3);
				}

				//方法二：
				//获取键值对的 set
				Set<Entry<Integer, String>> entrySet3 = map.entrySet();
				//用迭代方法取出键值对
				Iterator<Entry<Integer, String>> iterator5 = entrySet3.iterator();
				//使用while循环遍历
				while(iterator5.hasNext()){
					//取出每一个键值对对象 next
					Entry<Integer, String> next = iterator5.next();
					System.out.println(next.getKey() +"---"+ next.getValue());
				}
				//使用增强for遍历
				for (Entry<Integer, String> entry : entrySet3) {
					//使用增强for可以不要上面迭代去取键值对的方法和取出每一个键值对对象 next
					System.out.println(entry.getKey() +"---"+ entry.getValue());
				}
				//通过上面来看,推荐使用增强for来遍历，可以减少代码量