Java基础之集合

java集合可分为Collection和Map两种体系。

Collection接口：

|——List接口：存储有序的，可以重复的元素
* ** |——ArrayList（主要的实现类）、LinkedList（对于频繁的插入、删除操作）、Vector（古老的实现类、线程安全的）
|——Set接口：存储无序的，不可重复的元素
* * ** |——HashSet、LinkedHashSet、TreeSet

Map接口：具有映射关系”key-value对“的集合

Colletion接口常用方法

public class TestCollection {    @Test    public void testCollection3() {        Collection coll = new ArrayList();        coll.add(123);        coll.add(new String("AA"));        coll.add(new Date());        coll.add("BB");        coll.add(new Person("MM", 23));        Collection coll1 = new ArrayList();        coll1.add(123);        coll1.add(new String("AA"));        // 10.removeAll(Collection coll):从当前集合中删除包含在coll中的元素。        coll.removeAll(coll1);        System.out.println(coll);        //11.equals(Object obj):判断集合中的所有元素是否完全相同        Collection coll2 = new ArrayList();        coll2.add(123);        coll2.add(new String("AA1"));        System.out.println(coll1.equals(coll2));        //12.hashCode():        System.out.println(coll.hashCode());        System.out.println();        //13.toArray() :将集合转化为数组        Object[] obj = coll.toArray();        for(int i = 0;i < obj.length;i++){            System.out.println(obj[i]);        }        System.out.println();        //14.iterator():返回一个Iterator接口实现类的对象,进而实现集合的遍历！        Iterator iterator = coll.iterator();        //方式一：不用        /*System.out.println(iterator.next());        System.out.println(iterator.next());        System.out.println(iterator.next());*/        //方式二：不用//      for(int i = 0;i < coll.size();i++){//          System.out.println(iterator.next());//      }        //方式三：使用        while(iterator.hasNext()){            System.out.println(iterator.next());        }    }    @Test    public void testCollection2() {        Collection coll = new ArrayList();        coll.add(123);        coll.add(new String("AA"));        coll.add(new Date());        coll.add("BB");        // Person p = new Person("MM",23);        coll.add(new Person("MM", 23));        System.out.println(coll);        // 6.contains(Object obj):判断集合中是否包含指定的obj元素。如果包含，返回true，反之返回false        // 判断的依据：根据元素所在的类的equals()方法进行判断        // 明确：如果存入集合中的元素是自定义类的对象。要求：自定义类要重写equals()方法！        boolean b1 = coll.contains(123);        b1 = coll.contains(new String("AA"));        System.out.println(b1);        boolean b2 = coll.contains(new Person("MM", 23));        System.out.println(b2);        // 7.containsAll(Collection coll):判断当前集合中是否包含coll中所有的元素        Collection coll1 = new ArrayList();        coll1.add(123);        coll1.add(new String("AA"));        boolean b3 = coll.containsAll(coll1);        System.out.println("#" + b3);        coll1.add(456);        // 8.retainAll(Collection coll):求当前集合与coll的共有的元素，返回给当前集合        coll.retainAll(coll1);        System.out.println(coll);        // 9.remove(Object obj):删除集合中的obj元素。若删除成功，返回true。否则，返回false        boolean b4 = coll.remove("BB");        System.out.println(b4);    }    @Test    public void testCollection1() {        Collection coll = new ArrayList();        // 1.size():返回集合中元素的个数        System.out.println(coll.size());        // 2.add(Object obj):向集合中添加一个元素        coll.add(123);        coll.add("AA");        coll.add(new Date());        coll.add("BB");        System.out.println(coll.size());        // 3.addAll(Collection coll):将形参coll中包含的所有元素添加到当前集合中        Collection coll1 = Arrays.asList(1, 2, 3);        coll.addAll(coll1);        System.out.println(coll.size());        // 查看集合元素        System.out.println(coll);        // 4.isEmpty():判断集合是否为空        System.out.println(coll.isEmpty());        // 5.clear():清空集合元素        coll.clear();        System.out.println(coll.isEmpty());    }}

arraylist 常用方法
//ArrayList：List的主要实现类

 * List中相对于Collection，新增加的方法 *  void add(int index, Object ele):在指定的索引位置index添加元素ele    boolean addAll(int index, Collection eles)    Object get(int index):获取指定索引的元素    Object remove(int index):删除指定索引位置的元素    Object set(int index, Object ele):设置指定索引位置的元素为ele    int indexOf(Object obj):返回obj在集合中首次出现的位置。没有的话，返回-1    int lastIndexOf(Object obj)：返回obj在集合中最后一次出现的位置.没有的话，返回-1    List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex结束的左闭右开一个子list    List常用的方法：增(add(Object obj)) 删(remove) 改(set(int index,Object obj))                查(get(int index)) 插(add(int index, Object ele)) 长度(size())

注意:list集合判断重复元素 只需要重写equals方法 如使用coll.contains（）

//如果Person类没重写equals 返回false。反之返回turncoll.contains(new Person("得得"，23))coll.contains(new Person("得得"，23))

hashset
* Set:存储的元素是无序的，不可重复的！
* 1.无序性：无序性！= 随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
* 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。
*
* 说明：要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()方法。 进而保证Set中元素的不可重复性！
*
* Set中的元素时如何存储的呢？使用了哈希算法。
* 当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值
* 决定了此对象在Set中的存储位置。若此位置之前没有对象存储，则这个对象直接存储到此位置。若此位置
* 已有对象存储，再通过equals()比较这两个对象是否相同。如果相同，后一个对象就不能再添加进来。 万一返回false呢，都存储。（不建议如此）
* >要求：hashCode()方法要与equals()方法一致。

Hashmap
/*
* Object put(Object key,Object value):向Map中添加一个元素 Object remove(Object
* key):按照指定的key删除此key-value void putAll(Map t) void clear():清空 Object
* get(Object key)：获取指定key的value值。若无此key，则返回null boolean containsKey(Object
* key) boolean containsValue(Object value) int size():返回集合的长度 boolean
* isEmpty() boolean equals(Object obj)
*
* HashMap： 1.key是用Set来存放的，不可重复。value是用Collection来存放的，可重复
* 一个key-value对，是一个Entry。所有的Entry是用Set存放的，也是不可重复的。
* 2.向HashMap中添加元素时，会调用key所在类的equals()方法，判断两个key是否相同。若相同 则只能添加进后添加的那个元素。
*/

/*     * 如何遍历Map Set keySet() Collection values() Set entrySet()     */    @Test    public void test2() {        Map map = new HashMap();        map.put("AA", 213);        map.put("BB", 45);        map.put(123, "CC");        map.put(null, null);        map.put(new Person("DD", 23), 89);        // 1.遍历key集。        Set set = map.keySet();        for (Object obj : set) {            System.out.println(obj);        }        // 2.遍历value集        Collection values = map.values();        Iterator i = values.iterator();        while (i.hasNext()) {            System.out.println(i.next());        }        // 3.如何遍历key-value对。        // 方式一：        Set set1 = map.keySet();        for (Object obj : set1) {            System.out.println(obj + "----->" + map.get(obj));        }        // 方式二：        Set set2 = map.entrySet();        for (Object obj : set2) {            Map.Entry entry = (Map.Entry) obj;            // System.out.println(entry.getKey() + "---->" + entry.getValue());            System.out.println(entry);        }    }

Collections操作list的工具类

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

public class SortTest {      public static void main(String[] args) {          List<String> lists = new ArrayList<String>();          List<A> list = new ArrayList<A>();          List<B> listB = new ArrayList<B>();          lists.add("5");          lists.add("2");          lists.add("9");          //lists中的对象String 本身含有compareTo方法，所以可以直接调用sort方法，按自然顺序排序，即升序排序          Collections.sort(lists);          A aa = new A();          aa.setName("aa");          aa.setOrder(1);          A bb = new A();          bb.setName("bb");          bb.setOrder(2);          list.add(bb);          list.add(aa);          //list中的对象A实现Comparable接口          Collections.sort(list);          B ab = new B();          ab.setName("ab");          ab.setOrder("1");          B ba = new B();          ba.setName("ba");          ba.setOrder("2");          listB.add(ba);          listB.add(ab);          //根据Collections.sort重载方法来实现          Collections.sort(listB,new Comparator<B>(){              @Override              public int compare(B b1, B b2) {                  return b1.getOrder().compareTo(b2.getOrder());              }          });          System.out.println(lists);          System.out.println(list);          System.out.println(listB);      }  }  class A implements Comparable<A>{      private String name;      private Integer order;      public String getName() {          return name;      }      public void setName(String name) {          this.name = name;      }      public Integer getOrder() {          return order;      }      public void setOrder(Integer order) {          this.order = order;      }      @Override      public String toString() {          return "name is "+name+" order is "+order;      }      @Override      public int compareTo(A a) {          return this.order.compareTo(a.getOrder());      }  }  class B{      private String name;      private String order;      public String getName() {          return name;      }      public void setName(String name) {          this.name = name;      }      public String getOrder() {          return order;      }      public void setOrder(String order) {          this.order = order;      }      @Override      public String toString() {          return "name is "+name+" order is "+order;      }  }  打印的结果为：   [2, 5, 9]  [name is aa order is 1, name is bb order is 2]  [name is ab order is 1, name is ba order is 2]