集合

一.Collection

1.collection的常用方法

1. add(Object e)将元素e添加到集合coll中， obj所在类要求重写equals方法

2. size();获取添加的元素的个数

3. addAll(Collection coll1):将coll1集合中的元素添加到当前集合中

4. clear()清空集合元素

5. isEmpty()判断集合是否为空

6. contains(Object o) 会调用obj对象的equals方法

7. containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合

8. remove (object o)移除元素o

9. removeAll(Obeject coll1):从当前集合中删除coll1集合中的元素

10. retainAll(Object coll2):求当前几个与coll2的交集

11. hashCode():返回当前对象的哈希值

12. toArray():集合------>数组

13. 拓展：数组转换为集合：Arrays.asList()静态方法 List list = Arrays.asList(new String[]{"aa", "bb", "cc"}); System.out.println(list);

14.迭代器iterator

15.集合与数组之间的相互转换

      //toArray():集合------>数组
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]  );
        }
        //拓展：数组转换为集合：Arrays.asList()静态方法
        List list = Arrays.asList(new String[]{"aa", "bb", "cc"});
        System.out.println(list);

 

package CollectionTest;
​
import java.util.*;
​
/**
 * <h5>描述:</h5>
 */
public class CollectionDemo {
    public static void main(String[] args) {
        Collection coll=new ArrayList();
        //add(Object e)将元素e添加到集合coll中，  obj所在类要求重写equals方法
        coll.add("a");
        coll.add("123");//自动装箱
        coll.add(new Date());
        coll.add(new String("Tom"));
        //size();获取添加的元素的个数
        System.out.println(coll.size());
        Collection coll1=new ArrayList();
        coll1.add("bb");
        coll1.add("aa");
        //addAll(Collection coll1):将coll1集合中的元素添加到当前集合中
        coll.addAll(coll1);
        System.out.println(coll.size());
        System.out.println(coll);
        //clear()清空集合元素
//        coll.clear();
        //isEmpty()判断集合是否为空
        System.out.println(coll.isEmpty());
        //contains(Object o)  会调用obj对象的equals方法
        boolean a = coll.contains("a");
        System.out.println(a);
        System.out.println(coll.contains(new String("Tom")));
        //containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中
        System.out.println(coll.containsAll(coll1));
        //remove (object o)移除元素o
        System.out.println(coll.remove("a"));
        System.out.println(coll);
        //removeAll(Obeject coll1):从当前集合中删除coll1集合中的元素
        System.out.println(coll.removeAll(coll1));
        System.out.println(coll);
        Collection coll2=new ArrayList();
        coll2.add(123);
        coll2.add(new String("Tom"));
        //retainAll(Object coll2):求当前几个与coll2的交集
    coll.retainAll(coll2);
        System.out.println(coll);
        //hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());
        //toArray():集合------>数组
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]  );
        }
        //拓展：数组转换为集合：Arrays.asList()静态方法
        List list = Arrays.asList(new String[]{"aa", "bb", "cc"});
        System.out.println(list);
    }
}
​

迭代器方法

next();和hasNext()方法，用于遍历集合元素

内部定义了remove()方法，用于遍历是删除集合中的元素，此方法和集合中的方法不同

package CollectionTest;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
/**
 * <h5>描述:迭代器Iterator接口，集合元素的遍历</h5>
 * 内部定义了next()和hanNext()方法，用于遍历集合元素
 * 内部定义了rumove()方法，用于遍历是删除集合中的元素，此方法和集合中的方法不同
 */
public class IteratorTest {
    public static void main(String[] args) {
        Collection coll=new ArrayList();
        coll.add("abc");
        coll.add("drf");
        coll.add(123);
        coll.add(new String("yufou"));
        Iterator iterator= coll.iterator();
//        //演示方式一：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println("******************");
        //NoSuchElementException报异常
       // System.out.println(iterator.next());
while(iterator.hasNext()){
    Object obj = iterator.next();
    if ("yufou".equals(obj)){
        iterator.remove();//remove 删除迭代器中的元素
    }
}
Iterator iterator1=coll.iterator();//必须重新在建立一个迭代器
while (iterator1.hasNext()) {System.out.println(iterator1.next());}
        }
​
    }

2.List接口的常用方法

1.集合中的方法

2.List的方法

• add(int index,Object ele):在indenx位置插入ele元素

• addAll()添加集合中的所有元素

• get(int index)获取指定索引位置的元素

• indexOf(Object obj)返回集合中元素首次出现的索引位置，如果不存在返回-1.

• lastIndexOf(Object obj)返回集合中元素最后一次出现的索引位置，如果不存在返回-1.

• set(int index,Object obj)设置指定索引位置上的元素为obj；

• remove(int index,Object obj)删除指定索引位置的元素或者指定元素

• subList(int startIndex,int endIndex)截取指定索引区间的元素

package CollectionTest;
​
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
​
/**
 * <h5>描述:</h5>
 * List接口：存储有序的、可重复的数据---------------动态数组，替换原有数组
 * 三个实现类：
 * ArrayList：作为List接口的主要实现类,线程不安全，效率高，底层使用Object[]elementData存储
 * LinkedList:对于平凡的插入、删除操作，使用此类效率比ArrayList高，底层使用双向链表存储
 * Vector:作为List接口的古老实现类，线程安全，效率低,底层使用Object[]elementData存储
 */
public class ListTest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("aa");
        list.add(new String("tom"));
        System.out.println(list);
        System.out.println("*******************");
        list.add(1, "bb");//add(int index,Object ele):在indenx位置插入ele元素
        System.out.println(list);
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);//addAll()添加集合中的所有元素
        System.out.println(list.size());
        System.out.println(list.get(0));//get(int index)获取指定索引位置的元素
        int i = list.indexOf(456);//indexOf(Object obj)返回集合中元素首次出现的索引位置，如果不存在返回-1.
        System.out.println(i);
        int i1 = list.lastIndexOf(456);//lastIndexOf(Object obj)返回集合中元素最后一次出现的索引位置，如果不存在返回-1.
        System.out.println(i1);
        Object obj = list.remove(0);//remove(int index,Object obj)删除指定索引位置的元素或者指定元素
        System.out.println(list);
        System.out.println(obj);
        list.set(1,"cc" );//set(int index,Object obj)设置指定索引位置上的元素为obj；
        System.out.println(list);
        List list2 = list.subList(2, 4);//subList(int startIndex,int endIndex)截取指定索引区间的元素
        System.out.println(list2);
    }
}
​

小面试题

 

​
package CollectionTest;
​
import java.util.ArrayList;
import java.util.List;
​
/**
 * <h5>描述:</h5>
 */
public class ListPractise {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.remove(2);//删除的是3，这里的2 是索引
        System.out.println(list);
        list.remove(new Integer(2));//删除的是基本数据类型2
        System.out.println(list);
​
    }
}
​

3.Set接口

1. set接口的框架：

   • set接口：存储无序的、不可重复的数据--------->高中讲的集合

   • 三个实现类：

   • HashSet:Set接口的主要实现类；线程不安全的可以存储null值。

   • LinkedHashSet:作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序去遍历。

   • TreeSet:可以按照添加对象的指定属性，进行排序。

   • 1.Set作为接口，没有额外的定义新的方法，使用的都是Collecion中声明过的方法。

   • 2.要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()

   • 要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码

2. 一.Set存储无序的，不可重复的数据 * 以HasjSet为例说明： *1.Set的无序性：不等于随机性。 * 存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。 * 2.Set的不可重复性：保证的添加的元素按照equals()判断时，不能返回true，即相同的元素只能添加一个。 * 二.添加元素的过程:一HashSet为例: 我们向HashSet中添加元素a，首先调用元素a所在类的hashCode（）方法，计算元素a的哈希值， 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为索引位置），判断 数组此位之上是否已经有元素： 如果此位置上没有其他元素，则元素a添加成功。--------->情况一 如果此位置上有其他元素b（或以链表的形式存在的多个元素），则比较元素a与元素b的hash值： 如果hash值不相同，则元素a添加成功。--------->情况二 如果hash值相同，进而需要调用元素a所在类的equals（）方法： equals()返回true，元素a添加失败 equals()返回false，则元素a添加成功。--------->情况三

 

        对于添加成功的情况二和情况三而言：元素a与已经存在指定索引位置上的数据以链表的方式存储。
        jdk7:元素a放到数组中，指向原来的元素。
        jdk8:原来的元素在数组中，指向元素a。
        总结，七上八下
        HashSet底层：数组+链表的结构。

         LinkedHashSet:
        LinkedHashSet作为HashSet的子类，在父类的基础上，数据维护了两个新的应用，用来记录此数据的
        前一个和后一个数据。
        目的：对于频繁的遍历操作，LinkedHashSet效率高于HashSet。

package CollectionTest.Set;
​
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
​
/**
 * <h5>描述:</h5>
 * set接口的框架：
 *   set接口：存储无序的、不可重复的数据--------->高中讲的集合
 *   三个实现类：
 *   HashSet:Set接口的主要实现类；线程不安全的可以存储null值。
 *   LinkedHashSet:作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序去遍历。
 *   TreeSet:可以按照添加对象的指定属性，进行排序。
 *   1.Set作为接口，没有额外的定义新的方法，使用的都是Collecion中声明过的方法。
 *   2.要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
 *       要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码
 */
public class SetTest {
​
    public static void main(String[] args) {
        /*
        一.Set存储无序的，不可重复的数据
         *   以HasjSet为例说明：
         *1.Set的无序性：不等于随机性。
         * 存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
         * 2.Set的不可重复性：保证的添加的元素按照equals()判断时，不能返回true，即相同的元素只能添加一个。
         *
         二.添加元素的过程:一HashSet为例:
         我们向HashSet中添加元素a，首先调用元素a所在类的hashCode（）方法，计算元素a的哈希值，
         此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为索引位置），判断
         数组此位之上是否已经有元素：
         如果此位置上没有其他元素，则元素a添加成功。--------->情况一
         如果此位置上有其他元素b（或以链表的形式存在的多个元素），则比较元素a与元素b的hash值：
         如果hash值不相同，则元素a添加成功。--------->情况二
         如果hash值相同，进而需要调用元素a所在类的equals（）方法：
         equals()返回true，元素a添加失败
         equals()返回false，则元素a添加成功。--------->情况三
​
​
​
         对于添加成功的情况二和情况三而言：元素a与已经存在指定索引位置上的数据以链表的方式存储。
         jdk7:元素a放到数组中，指向原来的元素。
         jdk8:原来的元素在数组中，指向元素a。
         总结，七上八下
         HashSet底层：数组+链表的结构。
​
​
          LinkedHashSet:
         LinkedHashSet作为HashSet的子类，在父类的基础上，数据维护了两个新的应用，用来记录此数据的
         前一个和后一个数据。
         目的：对于频繁的遍历操作，LinkedHashSet效率高于HashSet。
        */
​
        Set set=new HashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new String("129"));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
​

package CollectionTest.Set;

import java.util.Iterator;
import java.util.TreeSet;

/**
 * <h5>描述:</h5>
 */
public class TreeSetTest {
    /*
    1.向TreeSet中添加的数据，要求是相同类的对象。
    2.两种排序方式：自然排序和定制排序
    3.自然排序中，比较两个对象是否相等的标准为：compareTo()返回0，不再是equals().
    4.定制排序中，比较两个对象是否相等的标准为：compare()返回0，不再是equals().
     */
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        //        举例一：
//        set.add(34);
//        set.add(-34);
//        set.add(43);
//        set.add(11);
//        set.add(18);
//        Iterator iterator = set.iterator();
//        while (iterator.hasNext()) {
//            System.out.println(iterator.next());
//        }
        set.add(new User("tom",12));
        set.add(new User("ject",34));
        set.add(new User("alice",45));
        set.add(new User("bont",23));
        set.add(new User("bont",64));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }


}
package CollectionTest.Set;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * <h5>描述:</h5>
 */
public class TreeSetTest2 {
    public static void main(String[] args) {
        Comparator com = 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());
//                }
                if (o1 instanceof User && o2 instanceof User) {
                    User u1=(User) o1;
                    User u2=(User) o2;
                    return u1.getname().compareTo(u2.getname()) ;
                }
                throw new RuntimeException("输入的数据类型错误");
            }
        };
        TreeSet set = new TreeSet(com);
        set.add(new User("tom",12));
        set.add(new User("ject",34));
        set.add(new User("alice",45));
        set.add(new User("bont",23));
        set.add(new User("bont",64));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }


    }
}

二.Map

1.Map的结构

 * <h5>描述:</h5>
 * 一.Map的结构：
 *  --------Map :双列数据，存储key-value对的数据--------类似于高中的函数：y=f(x)t
 *             实现类：
 *             1.HashMap:最为map的主要实现类；线程不安全的，效率高；可以存储null的key和value。
 *             --------------LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现便利。
 *                                                                  原因：在原有的HashMap底层结构的基础上，添加了一对指针，直向前一个和后一个数据
 *                                                                  对于频繁的遍历操作，李磊执行效率高于HashMap
 *            2. TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。
 *                                      底层使用红黑树。
 *             3.Hashtable:作为古老的实现类；线程安全，效率低；不可以存储null的key和value。
 *             ---------------Properties:常用来处理配置文件。key和value都是string类型
 *
 *             HashMap的底层：数组+链表（jdk7及之前）
 *                                                  数组+链表+红黑树（jdk8）
 *
 *
 * 二.Map结构的理解:
 *      Map中的key：无序的、不可重复的，使用Set存储所有的Key。--------->-key所在的类需要重写equals（0和Hashcode().一HashMap为例
 *      Map中的value：无序的、可重复的，使用Collection存储所有的value。------------------>value所在类需要重写equals（）方法
 *      一个键值对key-value构成了一个Entry对象。
 *      Map中的entry：无序的、不可重复的，使用Set存储所有的entry
 *
 *
 *      三.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的哈希值和已经存在的某一个数据的哈希值相同，继续比较：调用key1所在类的equals（）方法，比较：
 *                                          如果equals（）返回false：此时key1-value1添加成功；------------>情况3
 *                                          如果equals（）返回true：使用value1替换相同key1的value值。
 *
 *
 *                    补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储
 *                    在不断的添加过程中，会涉及到扩容问题，默认的扩容方式：扩容为原来容量的二倍，并将原有的数据复制过来。
 *
 *
 *                  jdk8相较于jdk7底层实现方面的不同：
 *                  1.new  HashMap()底层没有创建一个长度为16的数组
 *                  2.jdk8底层的数组是Node[],而非Entry[]。
 *                  3.首次调用put()方法时，底层穿件长度为16的数组
 *                  4.jdk7底层结构只有：数组+链表；jdk8底层结构：数组+链表+红黑树
 *                  当数组的某一个索引位置上的元素一链表形式存在的数据个数>8切当前数组的长度>64时，
 *                  此时此索引位置上的所有数据改为使用红黑树存储。
 *

2.Map的遍历

• 遍历所有的Key集：keySet()

• 遍历所有的value集：values()

• 遍历所有的key-value：entrySet(): Set set1 = map.entrySet(); Iterator iterator1 = set1.iterator(); while (iterator1.hasNext()) { Object obj = iterator1.next(); //entrySet集合中的元素都是entry Map.Entry entry=(Map.Entry)obj; System.out.println(entry.getKey()+"------------>"+entry.getValue());

@Test
    public void test2(){
    HashMap map=new HashMap();
    map.put(23,"abc2");
    map.put("abc","abc");
    map.put(3,"abc3");
    map.put("AA","abcA");
    //遍历所有的Key集：keySet()
    Set set = map.keySet();
    Iterator iterator = set.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
    //遍历所有的value集：values()
    Collection values = map.values();
    for (Object value : values) {
        System.out.println(value);
    }
    System.out.println( );
    //方式一
    //遍历所有的key-value：entrySet():
    Set set1 = map.entrySet();
    Iterator iterator1 = set1.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();
        Object value = map.get(key);//通过key获取value
        System.out.println(key+"----------->"+value);
    }
}

3.TreeMap

package MapTest;

import org.junit.Test;

import java.util.*;

/**
 * <h5>描述:</h5>
 */
public class TreeMapTest {
    //向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
    //因为要按照key进行排序：自然排序、定制排序
    @Test
    //自然排序
    public void  test1(){
        TreeMap map=new TreeMap();
        User u1=new User("tom",23);
        User u2=new User("jack",32);
        User u3=new User("jerry",25);
        User u4=new User("rose",18);
        map.put(u1,98   );
        map.put(u2,56   );
        map.put(u3,76   );
        map.put(u4,80   );

        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object key = iterator.next();
            Map.Entry entry=(Map.Entry) key;
            Object value = entry.getValue();
            Object key1 = entry.getKey();
            System.out.println(key1+"---------->"+value);
        }
    }
    //定制排序
    @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",32);
        User u3=new User("jerry",25);
        User u4=new User("rose",18);
        map.put(u1,98   );
        map.put(u2,56   );
        map.put(u3,76   );
        map.put(u4,80   );

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

4.Properties

package MapTest;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

/**
 * <h5>描述:</h5>
 */
public class PropertiesTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            Properties properties = new Properties();
            fis = new FileInputStream("jdbc.properties");

            properties.load(fis);//加载对应的流文件
            String name = properties.getProperty("name");
            String password = properties.getProperty("password");
            System.out.println(name);
            System.out.println(password);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {

            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}