java中的集合框架

cillian_bao

已于 2022-08-05 14:18:37 修改

阅读量247

点赞数

分类专栏： java那些事儿文章标签： java 开发语言前端

于 2022-06-27 14:23:04 首次发布

本文链接：https://blog.csdn.net/cillian_bao/article/details/125460369

版权

java那些事儿专栏收录该内容

23 篇文章 1 订阅

订阅专栏

前言

面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
Java集合可分为Collection和Map两种体系，Collection接口与Map接口属于并列的关系。
Collection接口又可分为两个子接口：List：元素有序、可重复的集合 Set:元素无序、不可重复的集合
Map接口：双列数据，保存存在映射关系的“key-value对"的集合。
整体框架图如下（实线表示继承，虚线表示实现）：

Map

集合与数组的对比

数组

数组在存储多个数据方面的特点：
一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
数组的缺点：
一旦初始化以后，其长度就不可修改。
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

集合

 |----Collection接口：单列集合，用来存 储一个一个的对象

     |----List接口：存储有序的、可重复的数据。  -->“动态”数组

         |----ArrayList、LinkedList、Vector

     |----Set接口：存储无序的、不可重复的数据   -->高中讲的“集合”

         |----HashSet、LinkedHashSet、TreeSet

 |----Map接口：双列集合，用来存储一对(key - value)一对的数据   -->高中函数：y = f(x)

         |----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

初始化集合的简便方法

 Collection coll=Arrays.asList(123,456);

1、Collection接口中的方法

1.1 contains()方法（需要注意是判断地址还是判断内容）

Collection coll = new ArrayList();
 coll.add(123);
 coll.add(456);
//        Person p = new Person("Jerry",20);
//        coll.add(p);
 coll.add(new Person("Jerry",20));
 coll.add(new String("Tom"));
 coll.add(false);
 //1.contains(Object obj):判断当前集合中是否包含obj
 //我们在判断时会调用obj对象所在类的equals()。
 boolean contains = coll.contains(123);
 System.out.println(contains);
 System.out.println(coll.contains(new String("Tom")));
//  System.out.println(coll.contains(p));//true
 System.out.println(coll.contains(new Person("Jerry",20)));//false -->true
 //2.containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
Collection coll1 = Arrays.asList(123,4567);
System.out.println(coll.containsAll(coll1));

在面对contains的时候，调用的是当前对象的equals方法，如果该对象没有重写过equals方法，那么根据父子类继承关系，其就会调用Object类的equals方法，我们知道Object中的equals方法直接用的是==,判断的是地址。
重写Person中的equals方法

 public boolean equals(Object o) {
     System.out.println("Person equals()....");
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     Person person = (Person) o;
     return age == person.age &&
             Objects.equals(name, person.name);
 }

调用时如果是ArrayList实现类，会对其中ArrayList中已经加入的元素依次比较(因为ArrayList是有序的,Person equals()依次调用与coll中的元素一一比较)，所以我们可以看到下面的Person equals()输出了三次，是把new Person(“Jerry”,20)这个对象依次与123，456，new Person(“Jerry”,20)进行比较，输出的情况如下：
输出情况
对我们的启发是:一般的自定义类都要重写equals()方法

1.2 containsAll()方法、remove()方法、removeAll()方法

这些都会调用相应参数的equals()方法。
remove()、removeAll()方法都会修改当前的对象。

1.3 retainAll()方法

求两个集合的交集,并返回给当前调用集合

   Collection coll = new ArrayList();
   coll.add(123);
   coll.add(456);
   coll.add(new Person("Jerry",20));
   coll.add(new String("Tom"));
   coll.add(false);

   //5.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
   Collection coll1 = Arrays.asList(123,456,789);
   coll.retainAll(coll1);
   System.out.println(coll);

1.4 equals()方法（集合中的equals方法）

集合与集合的相等比较，涉及到具体的类是有序的还是无序的，如果是有序的实现类ArrayList，那么纵使其中的所有元素都是相同的，如果顺序不同，比较也是不同的。如果实现的类是无序的，那么就是元素全部相同就行。

Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
  //6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。
  Collection coll1 = new ArrayList();
  coll1.add(456);
  coll1.add(123);
  coll1.add(new Person("Jerry",20));
  coll1.add(new String("Tom"));
  coll1.add(false);
  System.out.println(coll.equals(coll1));

集合到数组的相互转换

//8.集合 --->数组：toArray()
 Object[] arr = coll.toArray();
 for(int i = 0;i < arr.length;i++){
     System.out.println(arr[i]);
 }

 //拓展：数组 --->集合:调用Arrays类的静态方法asList()
 List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
 System.out.println(list);
 List arr1 = Arrays.asList(new int[]{123, 456});
 System.out.println(arr1.size());//1
 List arr2 = Arrays.asList(new Integer[]{123, 456});
 System.out.println(arr2.size());//2

2 、Iterator接口（设计模式的一种，为容器而生）

在集合中有一个iterator()方法可以获取一个iterator对象。

2.1 next()与hasNext()方法

Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);

Iterator iterator = coll.iterator();
System.out.println(iterator.next());
//遍历元素
  //方式三：推荐
  hasNext():判断是否还有下一个元素
  while(iterator.hasNext()){
      //next():①指针下移 ②将下移以后 集合位置上的元素返回
      System.out.println(iterator.next());
  }

每调用一次next()方法，指针就下移，执行hasNext()方法时指针不下移。
iterator

     //错误方式一：跳着输出。
Iterator iterator = coll.iterator();
 while((iterator.next()) != null){
    System.out.println(iterator.next());
  }

   //错误方式二：
   //集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
 while (coll.iterator().hasNext()){
     System.out.println(coll.iterator().next());
 }

remove()方法:迭代器中的remove方法

Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方
法，不是集合对象的remove方法。
如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，
再调用remove都会报IllegalStateException。
注意指针在什么地方，首次获得迭代器的时候，指针没有指向任何值，在整个集合的最上方。

        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //删除集合中"Tom"
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
//            iterator.remove();
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();
//                iterator.remove();
            }

        }
        //遍历集合
        iterator = coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

注意：Map中不能使用该迭代器，只有实现的collection集合才有iterator方法，比如List和set接口；而Map接口不能使用iterator方法，需要现获取set视图，即Set set ＝ map.keySet()；才能够使用

使用 foreach 循环遍历集合元素（增强for循环）

内部使用的仍然是迭代器。

   String[] arr = new String[]{"MM","MM","MM"};

//        //方式一：普通for赋值
//        for(int i = 0;i < arr.length;i++){
//            arr[i] = "GG";
//        }

     //方式二：增强for循环
     for(String s : arr){
         s = "GG";
     }

     for(int i = 0;i < arr.length;i++){
         System.out.println(arr[i]);
     }

增强for循环不能改变原数组/原集合中的变量的值，因为在修改forEach循环中的元素时，实际上是在修改迭代器在中分配的值int num，而不是原始数组的值。您得到的是文字，而不是指向数组中包含的对象的指针。

3、List接口

实现List接口的类：ArrayList,LinkedList,Vector。
相互的对比：

|----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
|----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
|----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

3.1 ArrayList的源码分析

3.1.1 jdk 7情况下

 ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
list.add(123);//elementData[0] = new Integer(123);
...
 list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
//默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

3.1.2 jdk 8中ArrayList的变化：

 ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
 list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
   ...
 后续的添加和扩容操作与jdk 7 无异。

小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

3.2 LinkedList源码分析

 LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性，默认值为null
 list.add(123);//将123封装到Node中，创建了Node对象。

其中，Node定义体现了LinkedList的双向链表的说法

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
    this.item = element;
    this.next = next;
    this.prev = prev;
    }
}

3.3 Vector源码分析（非常容易被deprcated)

Vector的源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。在扩容方面，默认扩容为原来的数组长度的2倍。

List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来
操作集合元素的方法。

void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置,如果不存在返回-1
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素.重载Collection中的remove方法
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合，本身list无变化，要取返回值

遍历的方法相较于Collection，可以通过索引获得相关的操作。

比较Collection方法与List接口中remove方法的不同，程序不自动装箱，我们自己装箱。

    public void testListRemove() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);//
    }

    private void updateList(List list) {
//        list.remove(2);
        list.remove(new Integer(2));
    }

上面的程序中第一个remove进行的操作是按index删除第二个元素，第二个remove进行的操作是按照元素进行元素2的删除。
为什么会出现上面的情况呢？因为我们对于List是能够通过索引进行操作的，这样程序就会造成歧义。

4、Set接口

具体的实现类：HashSet,LinkedHashSet(HashSet的子类）,TreeSet。

         |----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值

             |----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历

        对于频繁的遍历操作，LinkedHashSet效率高于HashSet.

         |----TreeSet：可以按照添加对象的指定属性，进行排序,对象必须是同一个类的对象。

Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。
无序性：不等于随机性。以HashSet(底层为数组）为例，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值进行添加。
不可重复性: 保证添加的元素按照equals()判断时，不能返回true.即：相同的元素只能添加一个。

4.1 HashSet：

HashSet底层：数组+链表的结构。
HashSet的底层其实是放在Map中，存放在Map键值对的键的位置。
HashSet

添加元素的过程：
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：
如果此位置上没有其他元素，则元素a添加成功。 —>情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
如果hash值不相同，则元素a添加成功。—>情况2
如果hash值相同，进而需要调用元素a所在类的equals()方法：
equals()返回true,元素a添加失败
equals()返回false,则元素a添加成功。—>情况2
对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素。
jdk 8 :原来的元素在数组中，指向元素a
总结：七上八下
对于以上的总结中的两个很重要的对象中需要重写的方法 hashCode()与equals()：
要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()
要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码
重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。

 @Override
 public boolean equals(Object o) {
     System.out.println("User equals()....");
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     User user = (User) o;
     if (age != user.age) return false;
     return name != null ? name.equals(user.name) : user.name == null;
 }

 @Override
 public int hashCode() { //return name.hashCode() + age;
     int result = name != null ? name.hashCode() : 0;
     result = 31 * result + age;
     return result;
 }

重写 hashCode() 方法的基本原则
在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode()
方法的返回值也应相等。
对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。
重写 equals() 方法的基本原则
以自定义的Customer类为例，何时需要重写equals()？
当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是
要改写hashCode()，根据一个类的equals方法（改写后），两个截然不
同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，
它们仅仅是两个对象。
因此，违反了“相等的对象必须具有相等的散列码”。
结论：复写equals方法的时候一般都需要同时复写hashCode方法。通
常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。
Eclipse/IDEA工具里hashCode()的重写
以Eclipse/IDEA为例，在自定义类中可以调用工具自动重写equals和hashCode。
问题：为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？
选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的
“冲突”就越少，查找起来效率也会提高。（减少冲突）
并且31只占用5bits,相乘造成数据溢出的概率较小。
31可以由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效
率）
31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结
果只能被素数本身和被乘数还有1来整除！(减少冲突)

	HashSet set = new HashSet();
	Person p1 = new Person(1001,"AA");
	Person p2 = new Person(1002,"BB");
	set.add(p1);
	set.add(p2);
	p1.name = "CC";
	set.remove(p1);
	System.out.println(set);
	set.add(new Person(1001,"CC"));
	System.out.println(set);
	set.add(new Person(1001,"AA"));
	System.out.println(set);

注意上面的remove在判断的时候也要先计算hashCode，然后根据hashCode的散列方法计算其在数组中的索引，然后判断是否能remove成功。
p1.name修改的时候确实导致了p1的哈希值发生了改变，从而导致我们在remove的时候，依赖p1的hash值计算出来的index值，没有一个与之匹配的，因为原来的p1未修改之前是根据name=“AA"时的hash值计算出来的index,所以remove掉p1这个对象是没有成功的。
同样的对于下面的代码再次add(new Person(1001,“CC”))的时候，加入也是成功的，因为位置还是不一样，到下面的add(new Person(1001,“AA”))的时候，加入为什么会成功呢？因为第一次计算new Person(1001,“AA”)hash值并且算出index的时候是和p1的位置是相等的，但是还要经过equals的计算才能算数，因为p1.name已经成为了"CC”,所以equals两者不相等，所以也加入成功了。

4.2 LinkedHashSet

LinkedList是HashSet的子类
为什么LinkedHashSet能够按添加的顺序输出？
LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。
优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet

4.3 TreeSet

TreeSet底层使用红黑树结构存储数据
向TreeSet中添加的数据，要求是相同类的对象。
两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator）
自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().

5、Map接口

Map接口
|----Map:双列数据，存储key-value对的数据 —类似于高中的函数：y = f(x)

|----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
|----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。
|----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
底层使用红黑树
|----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
|----Properties:常用来处理配置文件。key和value都是String类型
HashMap的底层：数组+链表（jdk7及之前）
数组+链表+红黑树（jdk 8）

当我们向Map中放键值对的时候，其实我们是在向其中存入Entry对象。
Map
Map中的key:无序的、不可重复的，使用Set存储所有的key–>如果是HashMap实现的要求key所在的类要重写equals()和hashCode()方法，如果是TreeSet实现的，要求实现相关的compare方法;
Map中的value:无序的、可重复的，使用Collection存储所有的value -->value所在的类要重写equals();
一个键值对：key-value构成了一个Entry对象。
Map中的entry:无序的、不可重复的，使用Set存储所有的entry;
底层内存结构：

5.1 HashMap

底层原理

JDK7下：
HashMap map = new HashMap():
在实例化以后，底层创建了长度是16的一维数组Entry[] table。
…可能已经执行过多次put…
map.put(key1,value1):
首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
如果此位置上的数据为空，此时的key1-value1添加成功。 ----情况1
如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据
的哈希值：
如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：
如果equals()返回false:此时key1-value1添加成功。----情况3
如果equals()返回true:使用value1替换value2。
补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
在不断的添加过程中，会涉及到扩容问题，当超出**临界值(且要存放的位置非空)**时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。

JDK7中底层的put源码
put
JDK8中的不同：

new HashMap():底层没有创建一个长度为16的数组
jdk 8底层的数组是：Node[],而非Entry[]
首次调用put()方法时，底层创建长度为16的数组
jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。
4.1 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

 DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16

 DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75

 threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12

 TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8

 MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

LinkedHashMap

new新的对象时重写了HashMap中的方法

LinkedHashMap
Map中的增删改

Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
 void putAll(Map m):将m中的所有key-value对存放到当前map中
 Object remove(Object key)：移除指定key的key-value对，并返回value
 void clear()：清空当前map中的所有数据
 
 //clear()
 map.clear();//与map = null操作不同
 System.out.println(map.size());
 System.out.println(map);

Map中的查询

 Object get(Object key)：获取指定key对应的value
 boolean containsKey(Object key)：是否包含指定的key
 boolean containsValue(Object value)：是否包含指定的value
 int size()：返回map中key-value对的个数
 boolean isEmpty()：判断当前map是否为空
 boolean equals(Object obj)：判断当前map和参数对象obj是否相等

Map中的遍历
获取key、value、Entry,它们是可以调用迭代器的，Map本身不能调用迭代器。

Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合

Map map = new HashMap();
 map.put("AA",123);
 map.put(45,1234);
 map.put("BB",56);

 //遍历所有的key集：keySet()
 Set set = map.keySet();
     Iterator iterator = set.iterator();
     while(iterator.hasNext()){
         System.out.println(iterator.next());
 }
 System.out.println();
 //遍历所有的value集：values()
 Collection values = map.values();
 for(Object obj : values){
     System.out.println(obj);
 }
 System.out.println();
 //遍历所有的key-value
 //方式一：entrySet()
 Set entrySet = map.entrySet();
 Iterator iterator1 = entrySet.iterator();
 while (iterator1.hasNext()){
  Object obj = iterator1.next();
  //entrySet集合中的元素都是entry,强制类型转换
  Map.Entry entry = (Map.Entry) obj;
  System.out.println(entry.getKey() + "---->" + entry.getValue());
 }
 System.out.println();
 //方式二：
 Set keySet = map.keySet();
 Iterator iterator2 = keySet.iterator();
 while(iterator2.hasNext()){
     Object key = iterator2.next();
     //map的get方法获取对应key的值。
     Object value = map.get(key);
     System.out.println(key + "=====" + valu
 }

Map.Entry是Map的内部接口，getKey()与getValue()是其内部的方法

TreeMap

向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
因为要按照key进行排序：自然排序、定制排序

Properties

Properties 类是 Hashtable 的子类，该对象用于处理属性文件,由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key
和 value 都是字符串类型,存取数据时，建议使用setProperty(String key,String value)方法和
getProperty(String key)方法
与jdbc.properties文件相互配合。

Properties pros = new Properties();
//Properties的load方法
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
System.out.println(user);

Collections工具类

就相当于我们对于数组而言，有数组工具类Arrays。
Collections 是一个操作 Set、List 和 Map 等集合的工具类
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，
还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

排序操作

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序，如果装的是整数，就调用Integer里面的compare方法。
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

查找、替换

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 对象的所有旧值

注意上面中的copy方法，要使得dest中的size等于src中的size。

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

同步控制
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

        //返回的list1即为线程安全的List
List list1 = Collections.synchronizedList(list);

cillian_bao

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java中的集合框架

集合:Collection,List,Set,Vector,Map
复制链接

扫一扫

专栏目录