Java——集合

集合的特点

1. 集合是Java中存储对象数据的一种容器

2. 集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。集合更像气球

3. 集合非常适合做元素的增删操作

   注意：集合中只能存储引用类型的数据，如果要存储基本类型的数据可以选择包装类

集合框架核心接口

——Java集合的接口和具体实现是分离的

——Java的集合框架中有两个基本的集合接口，一个是Collection,还一个是Map

Collection继承Iterable接口（JDK1.5+),这个接口允许对象成为”foreach"语句的目标

常用集合接口的特点

——set接口：是不包含重复元素的集合且无顺（无序不重复）；

——List接口：有序集合、允许有重复的元素（有序可重复）；

——Map接口：用于键/值映射，其中键唯一标识（不可重复）

注意：集合不支持基本类型

List集合

——List集合在Colletion基础上扩展的方法：

list.get(i) 读取第i位置的元素；

add(int index, E element) 指定位置添加元素

remove(int index)移除指定位置的元素

set(int index, E element)设置指定位置的元素内容，即修改subList(int fromIndex, int toIndex)截取子列表

LinkedList类本身还定义了一些其他的方法，用于快速操作和访问链表中的头尾元素。

——addFirst/addLast

——getFirst/getLast

——removeFirst/removeLast

——List常用的三种实现类

ArrayList类： ArrayList支持可随需要而增长的动态数组，随机读取快，随机增删慢

List<String> list = new ArrayList<>();
     list.add("《西游记》");
     list.add("《水浒传》");
     list.add("《红楼梦》");
     list.add("《三国演义》");
         
     //固定位置添加元素
     list.add(2,"《Java》");
     System.out.println(list);
         
     //foreach遍历
     for(String a:list) {
         System.out.println(a);
     }
     //for循环遍历
     for (int i = 0; i < list.size(); i++) {
         System.out.println(list.get(i));
     }
     //迭代器（Iterator）遍历
     //List转成迭代器对象
         int num = 2;
         Iterator<String> ite = list.iterator();
         while(ite.hasNext()) {
             //删除下标为2的内容
             if(ite.next()==num) {
                 ite.remove();
             }
         }
     //移除指定位置的元素
     list.remove(2);
     System.out.println(list);

LinkedList类：一个链接列表的数据结构的支持列表，随机读取慢，随机增删快

 LinkedList<String> list = new LinkedList<String>();
         list.add("《西游记》");
         list.add("《水浒传》");
         list.add("《红楼梦》");
         list.add("《三国演义》");
         
         list.addFirst("仙剑");
         list.addLast("Java");
         System.out.println(list);
         
         System.out.println(list.getFirst());
         System.out.println(list.getLast());
         
         list.removeFirst();
         list.removeLast();
         System.out.println(list);

Vector类：和ArrayList很相似都是动态数组，Vector是线程安全的

Set集合

——HashSet散列集合并不能确定其元素的排列顺序

Set<Integer>set = new HashSet<>();
         set.add(11);
         set.add(22);
         set.add(33);
         set.clear();//清楚set中所有元素
         //for循环遍历--不能在set中使用
         //foreach 遍历 可以在set中使用
         for(Integer d:set) {
             System.out.println(d);
         }
         //迭代器遍历  转成迭代器对象
         Iterator<Integer> iteset = set.iterator();
         while(iteset.hasNext()) {
             System.out.println(iteset.next());
         }

——TreeSet：使用树来进行存储的结构，存储的对象按自然顺序（升序）进行存储；

//treeSet----内部存储结构是树，他的集合值会根据自然排序输出
     TreeSet<Double> treeSet = new TreeSet<Double>();
     treeSet.add(78.0);
     treeSet.add(80.0);
     treeSet.add(87.4);
     treeSet.add(82.5);
     treeSet.add(92.5);
     treeSet.add(82.5);
     treeSet.add(92.5);
     System.out.println("TreeSet集合存储数据后输出的结果："+treeSet);
Map集合

——内部存储是以key – value对应的方式组织

Map<Integer,T> map = new HashMap<>();
         map.put(1, new T("root","123456"));
         //map遍历
         //第一种方式 foreach遍历
         for(Integer a:map.keySet()) {
             System.out.println("key值："+a+" value值："+map.get(a));
         }
         //第二种方式 Map转换成Set集合后在遍历 通过entrySet（）方法将map转成set
         for(Map.Entry<Integer, T> m : map.entrySet()) {
             System.out.println("key值："+m.getKey()+"value值："+map.get(m.getKey()));
         }
         //第三种方式 迭代器遍历  转成迭代器对象
         Iterator <Map.Entry<Integer, T>> imap = map.entrySet().iterator(); 
         while(imap.hasNext()) {
             Map.Entry<Integer, T> s = imap.next();
             System.out.println(s.getKey()+"value值："+map.get(s.getKey()));
         }

——常用实现类

HashMap

HashTable

TreeMap

——Map常用操作方法

功能	方法描述	说明
大小	int size()	返回Map中键值关系元素个数。
包含key测试	boolean containsKey(Object key)	如果Map中包含指定键则返回 true
包含值测试	boolean containsValue(Object v)	如果Map中包含指定值则返回 true
取key对应值	V get(Object key)	返回键对应的值，不存在返回null
插入	V put(K key, V value)	将键值对应关系添加到Map中
删除	V remove(Object key)	返回集合的列表迭代器
清空	void clear()	清空Map
取所有key的集合	Set<K> keySet()	返回所有key的Set集合
返回 值列表	Collection<V> values()	返回所有值Collection列表
返回Entry的集合	Set<Map.Entry<K,V>> entrySet()	返回Entry的集合，一个Entry包含了一个Key和一个Value

迭代器的引入

——对 collection 进行迭代的迭代器。

该接口的方法有hasNext：判断集合中是否仍有元素可以迭代

next：返回迭代的下一个元素

remove：从迭代器指向的集合中移除迭代器所返回的元素

——只能单向的遍历，无法随机独区或者从后往前遍历

ListIterator：针对List的迭代器，是对Iterator的扩展，允许双向遍历列表，并且可以修改单元扩展了一些方法

add：往List中添加一个元素

hasPrevious：逆向遍历List判断是否有元素可迭代

previous：返回List中的前一个元素

nextIndex：返回对next的后续调用所返回元素的索引值

previousIndex：返回对previous的后续调用所返回元素的索引

set：用指定的元素替换next或者previous所返回的元素

Collections类（静态方法）

sort(List<T> list)：将集合List的进行按照升序进行排序

binarySearch(List<? extends Comparable<? super T>> list, T key)二分查找List中的元素

copy(List<? super T> dest, List<? extends T> src)：将src中的数据复制到dest中

max(Collection<? extends T> coll)：获取集合中最大的元素

min(Collection<? extends T> coll)：获取集合中最小的元素

reverse(List<?> list)：将List进行反转

 Collections.sort(list); 
     System.out.println(list);
     //copy
     List<Integer> list1 = new ArrayList<>();
     list1.add(66);
     list1.add(666);
     Collections.copy(list,list1);//list1中的复制到list中
     System.out.println(Collections.max(list));
     System.out.println(list);

 [1, 2, 3, 4]
 666
 [66, 666, 3, 4]

排序

——Comparator（外部的）是比较接口,通过实现Comparator来新建一个比较器，然后通过这个比较器对类进行排序。

 1.定义在要比较的类之外，需要单独再写一个类实现该接口，实现的方法是compare

public class MyComparator implements Comparator<Employee>
 {
  public int compare(Employee o1, Employee o2)  {
         // TODO Auto-generated method stub
         //return o1.id.compareTo(o2.id);//可能会报错应转成字符串类型
         return (String.valueOf(o1.getId())).compareTo(String.valueOf(o2.getId()));
     }
 }

 2.使用时传递集合以及一个比较器对象

 Collections.sort(list2,new MyComparator());

——Comparable（内部的）是排序接口,若一个类实现了Comparable接口，就意味着该类支持排序。此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

 public class Employee implements Comparable<Employee>
 {
 public int compareTo(Employee o) {
         // TODO Auto-generated method stub
         return this.id.compareTo(o.id);
     }
 }

Comparable和Comparator对比

与Comparable相比，Comparable是类本身具有排序能力， Comparator相当于定义一个比较的规则用来比较两个对象Comparable是排序接口，若一个类实现了Comparable接口，就意味着“该类支持排序”。而Comparator是比较器，我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。一个类只能实现一次Comparable，因此只能确定一种排序规则，而Comparator作为外部比较器，可以方便的定义多个比较规则，在需要的地方传递不同的比较器对象