Java入门笔记 09-集合

一、Collection接口方法：Collection 接口是 List、Set 和 Queue 接口的父接口,该接口里定义的方法既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List)实现。

1、添加

• add(Object obj)
• addAll(Collection coll):将coll中的元素添加到当前集合中

2、获取有效元素的个数

• int size()

3、清空集合

• void clear()

4、是否是空集合

• boolean isEmpty()

5、是否包含某个元素

• boolean contains(Object obj):判断是否包含obj,是通过元素的equals方法来判断是否是同一个对象
• boolean containsAll(Collection c):也是调用元素的equals方法来比

较的。拿两个集合的元素挨个比较。
6、删除

• boolean remove(Object obj) :通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
• boolean removeAll(Collection coll):取当前集合的差集

7、取两个集合的交集

• boolean retainAll(Collection c):把交集的结果存在当前集合中,不影响c

8、集合是否相等

• boolean equals(Object obj)

9、转成对象数组

• Object[] toArray()

10、获取集合对象的哈希值

• hashCode()

11、遍历

• iterator():返回迭代器对象,用于集合遍历

二、Iterator迭代器接口：

• Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。迭代器模式,就是为容器而生；
• Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象；
• Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力，如果需要创建Iterator 对象,则必须有一个被迭代的集合；
• 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。

 @Test //迭代器中的remove()
 public void test2(){
     Collection collection1 = new ArrayList();
     collection1.add("A");
     collection1.add("B");
     collection1.add("Jerry");

     //移除操作
     Iterator iterator = collection1.iterator();
     while(iterator.hasNext()){
         Object next = iterator.next();
         if("B".equals(next))
             iterator.remove();

     }

     //从头开始遍历
     iterator = collection1.iterator();//必须重新生成，不然接上面的集合最后
     while(iterator.hasNext()){
         System.out.println(iterator.next());
     }
 }

　　注意:

• Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
• 如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法,再调用remove都会报IllegalStateException。

三、Collection子接口——List：List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。

　　1. List接口常用方法：

• 增：add(Object o)
• 删：remove(int index)/remove(Object o)
• 改：set(int index, Object o)
• 查：get(int index)
• 插：add(int index, Object o)
• 长度：size()
• 遍历：

|--- Iterator迭代器
    |--- for
    |--- foreach

 public class ListTest {
     @Test
     public void test1(){
         ArrayList list = new ArrayList();
         list.add(123);
         list.add("A");
         list.add(456);
         System.out.println("原始：" + list);

         //void add(int index, Object ele):在index位置插入ele元素
         list.add(0,"B");
         System.out.println("add(0,B):" + list);

         //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
         List list1 = Arrays.asList(1,2,3);
         list.addAll(2,list1);
         System.out.print("list1" + list1 + "*** ");
         System.out.println("addAll(2,list1):" + list);

         //Object get(int index):获取指定index位置的元素
         System.out.println(list.get(0));
     }

     @Test
     public void test2(){
         ArrayList list = new ArrayList();
         list.add(456);
         list.add(123);
         list.add("A");
         list.add(456);
         System.out.println("原始：" + list);

         //int indexOf(Object obj):返回obj在集合中首次出现的位置,没有返回-1
         System.out.println(list.indexOf("A"));//2

         //int lastIndexOf(Object obj):返回obj在当前集合中最后一次出现的位置
         System.out.println(list.lastIndexOf(456));//3

         //Object remove(int index):移除指定index位置的元素,并返回此元素
         System.out.println(list.remove(0));
         System.out.println("remove 0 后：" + list);

         //Object set(int index, Object ele):设置指定index位置的元素为ele,并返回index处的元素
         System.out.println(list.set(0,567));
         System.out.println("set(0,567)后：" + list);

         //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合,左闭右开
         System.out.println("subList(0,2): " + list.subList(0,2));
         System.out.println("list: " + list);
     }

     //遍历
     @Test
     public void test3(){
         ArrayList list = new ArrayList();
         list.add(456);
         list.add(123);
         list.add("A");
         list.add(456);

         //Iterator迭代器
         Iterator iterator = list.iterator();
         while(iterator.hasNext())
             System.out.println(iterator.next());
         System.out.println();

         //foreach
         for(Object o: list){
             System.out.println(o);
         }
         System.out.println();

         //for
         for(int i=0;i<list.size();i++)
             System.out.println(list.get(i));
     }
 }

　　2. List的实现类ArrayList：ArrayList 是 List 接口的典型实现类、主要实现类，非线程安全，效率高，底层使用Object数组存储。

　　3. List的实现类LinkedList：对于频繁的插入或删除元素的操作,建议使用LinkedList类,效率较高，底层是双向链表，新增如下方法：

• void addFirst(Object obj)
• void addLast(Object obj)
• Object getFirst()
• Object getLast()
• Object removeFirst()
• Object removeLast()

　　4. List的实现类Vector：Vector 是一个古老的集合,JDK1.0就有了。大多数操作与ArrayList相同,区别之处在于Vector是线程安全的。

　　面试题：请问ArrayList/LinkedList/Vector的异同?谈谈你的理解?ArrayList底层是什么?扩容机制?Vector和ArrayList的最大区别?

　　ArrayList和LinkedList的异同：

• 二者都线程不安全,相对线程安全的Vector,执行效率高。
• 此外,ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove,LinkedList比较占优势,因为ArrayList要移动数据。

　　ArrayList和Vector的区别：

• Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized),属于强同步类。因此开销就比ArrayList要大,访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。
• Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。Vector还有一个子类Stack。

四、Collection子接口——Set：Set接口是Collection的子接口,set接口没有提供额外的方法，Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set 集合中,则添加操作失败。Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法。

　　1. Set的实现类HashSet：HashSet 是 Set 接口的典型实现,大多数时候使用 Set 集合时都使用这个实现类。HashSet 按 Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除性能。

　　HashSet 具有以下特点:

• 不能保证元素的排列顺序
• HashSet 不是线程安全的
• 集合元素可以是 null

　　HashSet 集合判断两个元素相等的标准:两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等。因此对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Objectobj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。

　　添加元素的过程，以HashSet为例：首先利用hash值确定index，若此index上有元素：

• hash值不同，添加成功
• hash值相同，调用该对象所在类的equals方法
  • true：添加失败
  • false：添加成功

　　2. Set的实现类LinkedHashSet：是 HashSet 的子类，根据元素的 hashCode 值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。LinkedHashSet插入性能略低于 HashSet,但在迭代访问 Set 里的全部元素时有很好的性能。

 @Test
 public void test2(){
     Set set = new LinkedHashSet();
     set.add(123);
     set.add(456);
     set.add("A");
     set.add(new Integer(789));

     Iterator iterator = set.iterator();
     while(iterator.hasNext())
         System.out.println(iterator.next());
 }

　　3. Set的实现类TreeSet：是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态，使用红黑树结构存储数据。新增如下方法：

• Comparator comparator()
• Object first()
• Object last()
• Object lower(Object e)
• Object higher(Object e)
• SortedSet subSet(fromElement, toElement)
• SortedSet headSet(toElement)
• SortedSet tailSet(fromElement)

　　3.1 自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列。因此如果试图把一个对象添加到 TreeSet 时,则该对象的类必须实现 Comparable接口。向 TreeSet 中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较。因为只有相同类的两个实例才会比较大小,所以向 TreeSet 中添加的应该是同一个类的对象。对于 TreeSet 集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过 compareTo(Object obj) 方法比较返回值，不再是equals方法。

 public class TreeSetTest {
     @Test
     public void test2(){
         TreeSet set = new TreeSet();
         set.add(new User("Amy",12));
         set.add(new User("Bob",13));
         set.add(new User("Emily", 14));
         set.add(new User("Dean", 15));
         set.add(new User("Dean", 16));

         Iterator iterator = set.iterator();
         while(iterator.hasNext())
             System.out.println(iterator.next());
     }
 }

 class User implements Comparable{
     private String name;
     private int age;

     public User() {
     }

     public User(String name, int age) {
         this.name = name;
         this.age = age;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     @Override
     //按照姓名从大到小排列，年龄从小到大
     public int compareTo(Object o) {
         if(o instanceof User){
             User user = (User)o;
             int compare = -this.name.compareTo(user.name);
             if(compare == 0){
                 return Integer.compare(this.age, user.age);
             }else
                 return compare;

         }else{
             throw new RuntimeException("输入的类型不匹配");
         }
     }

     /*
     @Override
     //按照姓名从小到大排列
     public int compareTo(Object o) {
         if(o instanceof User){
             User user = (User)o;
             return this.name.compareTo(user.name);
         }else{
             throw new RuntimeException("输入的类型不匹配");
         }
     }
     */

     @Override
     public String toString() {
         return "name: " + name + ", age: " + age;
     }
 }

　　3.2 定制排序：在定制排序中，比较两个对象是否相同的标准为：compare方法的返回值，不再是equals方法。

 @Test
 public void test3(){
     Comparator com = new Comparator() {
         //按照年龄从小到大，年龄一样的数据只要一个
         @Override
         public int compare(Object o, Object t1) {
             if(o instanceof User && t1 instanceof User){
                 User u1 = (User)o;
                 User u2 = (User)t1;
                 return Integer.compare(u1.getAge(), u2.getAge());
             }else{
                 throw new RuntimeException("输入的数据类型不匹配");
             }
         }
     };

     TreeSet set = new TreeSet(com);
     set.add(new User("Amy",12));
     set.add(new User("Bob",12));
     set.add(new User("Emily", 14));
     set.add(new User("Dean", 15));
     set.add(new User("Dean", 16));

     Iterator iterator = set.iterator();
     while(iterator.hasNext())
         System.out.println(iterator.next());
 }

五、Map接口：用于保存具有映射关系的数据:key-value，类似与高中讲的函数的概念。

　　0. Map结构的理解：

• key：无序、不可重复，使用Set存储所有的key；--->要求key所在的类重写equals和hashcode方法（以HashMap为例的）
• value：无序、可重复，使用Collection存储所有的value。--->要求value所在的类重写equals方法
• 一个key-value对构成了一个Entry对象。entry是无序、不可重复的。

1. Map接口常用方法：

 public class MapTest {
     @Test
     //增删改
     public void test1(){
         //put
         HashMap hashMap = new HashMap();
         hashMap.put("AA",123);
         hashMap.put("BB",456);
         hashMap.put("CC",789);
         hashMap.put("AA",101);

         System.out.println(hashMap);//{AA=101, BB=456, CC=789}相当于原有的123被改为101

         //putAll
         HashMap hashMap1 = new HashMap();
         hashMap1.put("DD",102);
         hashMap1.putAll(hashMap);
         System.out.println(hashMap1);

         //remove(key),返回对应key的value并删除该entry
         System.out.println(hashMap.remove("AA"));
         System.out.println(hashMap);

         //clear
         hashMap1.clear();
         System.out.println(hashMap1);
     }

     @Test
     //查询
     public void test2(){
         HashMap hashMap = new HashMap();
         hashMap.put("AA",123);
         hashMap.put("BB",456);
         hashMap.put("CC",789);

         //get
         System.out.println(hashMap.get("AA"));

         //containsKey
         System.out.println(hashMap.containsKey("DD"));

         //containsValue
         System.out.println(hashMap.containsValue(789));

         //size
         System.out.println(hashMap.size());

         //isEmpty
         System.out.println(hashMap.isEmpty());
     }

     @Test
     //遍历
     public void test3(){
         HashMap hashMap = new HashMap();
         hashMap.put("AA",123);
         hashMap.put("BB",456);
         hashMap.put("CC",789);

         //keySet,返回一个Set
         Set set = hashMap.keySet();
         Iterator iterator = set.iterator();
         while(iterator.hasNext())
             System.out.println(iterator.next());

         //values,返回一个Collection
         Collection values = hashMap.values();
         Iterator iterator2 = values.iterator();
         while(iterator2.hasNext())
             System.out.println(iterator2.next());

         //entrySet,返回一个Set
         Set set1 = hashMap.entrySet();
         Iterator iterator1 = set1.iterator();
         while(iterator1.hasNext()){
             Object object = iterator1.next();
             Map.Entry entry = (Map.Entry) object;
             System.out.println(entry.getKey() + "--->" + entry.getValue());
         }
     }
 }

2. HashMap：作为Map的主要实现类，线程不安全，效率高，可以存储null，底层是数组+链表（jdk8及以后+红黑树）

3. LInkedHashMap：作为HashMap的子类，保证了遍历map元素时按照添加时的顺序遍历。对于频繁遍历的操作，此类执行的效率高于HashMap

4. TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然/定制排序，底层使用红黑树。要求都是同一个类

 public class TreeMapTest {

     @Test
     //自然排序
     public void test1(){
         TreeMap map = new TreeMap();
         User u1 = new User("Tom",23);
         User u2 = new User("Jack",12);
         User u3 = new User("Bob",21);

         map.put(u1, 90);
         map.put(u2, 81);
         map.put(u3, 62);

         Set set1 = map.entrySet();
         Iterator iterator1 = set1.iterator();
         while(iterator1.hasNext()){
             Object object = iterator1.next();
             Map.Entry entry = (Map.Entry) object;
             System.out.println(entry.getKey() + "--->" + entry.getValue());
         }
     }

     @Test
     //定制排序:定制按照年龄排序
     public void test2(){
         TreeMap map = new TreeMap(new Comparator() {
             @Override
             public int compare(Object o1, Object o2) {
                 if(o1 instanceof User && o2 instanceof User){
                     User u1 = (User)o1;
                     User u2 = (User)o2;
                     return Integer.compare(u1.getAge(), u2.getAge());
                 }
                 throw new RuntimeException("输入的类型不匹配");
             }
         });
         User u1 = new User("Tom",23);
         User u2 = new User("Jack",12);
         User u3 = new User("Bob",21);

         map.put(u1, 90);
         map.put(u2, 81);
         map.put(u3, 62);

         Set set1 = map.entrySet();
         Iterator iterator1 = set1.iterator();
         while(iterator1.hasNext()){
             Object object = iterator1.next();
             Map.Entry entry = (Map.Entry) object;
             System.out.println(entry.getKey() + "--->" + entry.getValue());
         }
     }
 }

5. Hashtable：作为古老的实现类，线程安全的，效率低，不能存储null

　　|--- Properties：常用来处理配置文件，key和value都是String类型。

 public class PropertiesTest {
     public static void main(String[] args) throws IOException {
         Properties properties = new Properties();

         FileInputStream fis = new FileInputStream("jdbc.properties");
         properties.load(fis);

         String name = properties.getProperty("name");
         String password = properties.getProperty("password");

         System.out.println(name + " " + password);
     }
 }

六、Collections工具类：Collections 是一个操作 Set、List 和 Map 等集合的工具类

　　1. 排序操作:(均为static方法)

• reverse(List):反转 List 中元素的顺序
• shuffle(List):对 List 集合元素进行随机排序
• sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
• sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
• swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换

　　2. 查找、替换：

• Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
• Object max(Collection,Comparator):根据 Comparator 指定的顺序,返回给定集合中的最大元素
• Object min(Collection)
• Object min(Collection,Comparator)
• int frequency(Collection,Object):返回指定集合中指定元素的出现次数
• void copy(List dest,List src):将src中的内容复制到dest中
• boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List 对象的所有旧值

 public class CollectionsTest {
     @Test
     public void test(){
         List list = new ArrayList();
         list.add(1);
         list.add(2);
         list.add(3);

         List list1 = Arrays.asList(new Object[list.size()]);
         Collections.copy(list1, list);
         System.out.println(list1);
     }
 }