程序设计基础·Java学习笔记·集合

 

 

一、集合

（一）Java集合

　　1.概述：Java集合类存放与java.util包中，是一个用来存放对象的容器；

 

　　2.特点：Java集合的特点

　　（1）集合只能存放对象；比如存放一个int型数据1放入到集合中，其实它是自动转换成Integer类之后存入的，Java中每一种基本类型都有对应的引用类型；

　　（2）集合存放的是多个对象的引用，对象本身还是放在堆内存中；

　　（3）集合可以存放不同类型，不限数量的数据类型；

 

　　3.体系：Java集合可分为Set、List、Map三种大体系

　　（1）Set：无序、不可重复的集合；

　　（2）List：有序、可重复的集合；

　　（3）Map：具有映射关系的集合；

 

　　4.在JDK5后，增加了泛型，Java集合可以记住容器中对象的数据类型；

 

 

（二）HashSet

　　1.HashSet是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。我们大多数时候说的Set集合指的都是HashSet；

 

　　2.HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能；

 

　　3.HashSet具有以下特点：

　　（1）不能保证元素的排列顺序；

　　　　解释：当向HashSet集合中存入一个元素时，HashSet会调用该对象的 hashCode() 方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的储存位置；

　　（2）不可重复；（指hashCode不相同）

　　　　解释：如果两个元素的 equals() 方法返回true，但它们的 hashCode() 返回值不相等，HashSet将会把它们存储在不同的位置，但依然可以添加成功；

　　（3）HashSet不是线程安全的；

　　（4）集合元素可以存null；

　　4.HashSet类 👉实现👉 Set接口 👉继承👉 Collection接口，即HashSet类最终来自于Collection接口的方法；

 

　　5.Collection接口的方法：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Example_01 {
    public static void main(String[] args) {
        Set set = new HashSet();

        //add：添加元素
        set.add(1);
        set.add("a");
        //验证集合的不可重复性
        //此处加入和上述中一样的元素a，但是发现读取大小时，个数仍然是2；
        //并且在输出集合时，只有一个a，则证明集合的不可重复性；
            set.add("a");
            System.out.println(set.size());
        //set可存储null元素,null也占一个位置；
            set.add(null);
            System.out.println(set.size());
        System.out.println(set);

        //remove：移除一个数据
        set.remove(1);
        System.out.println(set);

        //contains：判断
        //判断集合中有没有值0，所以要使用打印输出这个布尔值；
        System.out.println(set.contains(0));

        //clear：清空
        set.clear();
        System.out.println(set);

        //遍历集合
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("e");
        System.out.println(set);
        //方法一：使用迭代器遍历集合
        Iterator it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //方法二：for each迭代集合
        //把set集合中每个元素取出赋值给引用变量obj，直到循环set的所有值；
        for (Object obj : set){
            System.out.println(obj);
        }

        //集合大小：集合中元素的个数
        System.out.println(set.size());
    }
}

 

　　6. hashCode() 方法

　　（1）HashSet集合判断两个元素相等的标准：两个对象通过equals() 方法比较相等，并且两个对象的 hashCode() 方法返回值也相等；

　　（2）如果两个对象通过 equals() 方法返回true，这两个对象的hashCode也应该相同；

 

　　7.泛型

//使用泛型：让集合只能存同样类型的对象；
//前后都加入以<>为包裹的数据类型；
Set<String> set01 = new HashSet<String>();

//同理，以下两段代码等价；
Set set = new HashSet();
Set<Object> set = new HashSet<Object>();

 

 

 （三）TreeSet

　　1.TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序态度；

 

　　2.TreeSet支持两种排序方法：自然排序和定制排序；默认情况下，TreeSet采用自然排序；

 

　　3.TreeSet类 👉实现👉 NavigableSet接口 👉继承👉 SortedSet接口 👉继承👉 Set接口 👉继承👉 Collection接口；

 

　　4.自然排序：TreeSet会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序排列；

　　（1）如果this > obj，返回正数 1；

　　（2）如果this < obj，返回负数 -1；

　　（3）如果this = obj，返回0，则认为这两个对象相等；

　　（4）必须放入同样类的对象（默认会进行排序），否则可能会发生类型转换异常；我们可以使用泛型来进行限制；

 

　　5.TreeSet的一些接口：

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

public class Tree_Set {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<Integer>();

        //TreeSet的自然排序
        set.add(5);
        set.add(1);
        set.add(3);
        set.add(4);
        System.out.println(set);
        //删除元素
        set.remove(5);
        //判断元素
        set.contains(0);
        //清空元素
        set.clear();

        //遍历集合
        //方法一：使用迭代器遍历集合；
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //方法二：for each迭代集合，推荐使用；
        for(Integer i : set){
            System.out.println(i);
        }

    }
}

 

　　6.TreeSet中的正序排列方法：

　　（1）示例：

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class Tree_Set {
    public static void main(String[] args) {

        Person p1 = new Person("张三",18);
        Person p2 = new Person("里斯",19);
        Person p3 = new Person("格雷福斯",20);
        Person p4 = new Person("王二",17);

        Set<Person> set = new TreeSet<Person>(new Person());
        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p4);

        for(Person px : set){
            System.out.println(px.name + px.age);
        }
    }
}
class Person implements Comparator<Person> {
    int age;
    String name;
    public Person(){}
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    @Override
    //重写方法中，按照年龄进行了正序排序
    public int compare(Person o1, Person o2) {
        if(o1.age > o2.age){
            return 1;
        }  else if(o1.age < o2.age){
            return -1;
        }  else{
            return 0;
        }
    }
}

　　（2）定制排序中，使用Comparator作为接口进行调用，同时要通过泛型来确定范围；

 

　　（3）接口调用后要进行 compare() 方法的重写，返回值1时，如果判断是大于，那么就是正序排列；如果判断是小于，那么就是负序排列；

 

 

（四）List和ArrayList

　　1.List代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引；

　　

　　2.List允许使用重复元素，可以通过索引来访问指定位置的集合元素；

 

　　3.List默认按元素的添加顺序设置元素的索引；

 

　　4.List集合里添加了一些根据索引来操作集合元素的方法；

 

　　5.List接口的用法：

import java.util.ArrayList;
import java.util.List;

public class List_ArrayList_01 {
    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("b");//第一个，索引下标 0；
        list.add("a");//第二个，索引下标 1；
        list.add("d");//第三个，索引下标 2；
        list.add("c");//第四个，索引下标 3；
        list.add("b");//第五个，索引下标 4；
        //可重复性：在运行中，集合会出现两次元素"b"
        System.out.println(list);
        //通过索引找到下标为3的元素"c"
        System.out.println(list.get(3));

        //在指定索引下标位置插入数据
        List<String> l = new ArrayList<String>();
        l.add("123");
        l.add("456");
        //在addAll方法中，第一个值为index，即加入的索引下标位置，第二个为加入的对象；
        list.addAll(2,l);
        System.out.println(list);

        //获取指定元素在集合中第一次出现的所有下标；
        System.out.println(list.indexOf("b"));
        //获取指定元素在集合中最后一次出现的所有下标；
        System.out.println(list.lastIndexOf("b"));

        //删除指定下标的元素
        list.remove(2);
        System.out.println(list);

        //修改指定下标的元素
        list.set(2,"789");
        System.out.println(list);

        //截取目标集合(根据索引下标的起始位置截取一段元素形成一段新的集合)
        List<String> sublist = list.subList(3,6);
        //输出发现，新集合是一个左闭右开的集合；
        System.out.println(sublist);
    }
}

 

　　6.ArrayList和Vector

　　（1）ArrayList和Vector是List接口的两个典型实现；

　　（2）区别：Vector是一个古老的集合；Vector是线程安全的；

 

 

（五）Map集合

　　1.Map集合概述：Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的Key，另外一组用于保存Map里的Valye；

　　

　　2.Map中的Key和Value都是可以任何引用类型的数据；

 

　　3.Map中的Key不允许重复，即同一个Map对象的任何两个Key通过equals放比较中返回false；

 

　　4.Key和Value之间存在单向一对一关系，即同故宫特定的Key总能找到唯一的、确定的Value；

 

　　5.Map和HsahMap类：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapORMap {
    public static void main(String[] args) {

        Map<String,Integer> map = new HashMap<String, Integer>();
        //添加数据,在存储数据时，key必须不同，value可以相同
        map.put("b",1);
        map.put("c",2);
        map.put("e",2);
        System.out.println(map);

        //根据key取值
        System.out.println(map.get("c"));

        //根据key移除键值对
        map.remove("c");
        System.out.println(map);

        //判断当前map集合是否包含指定的key
        System.out.println(map.containsKey("c"));
        //判断当前map集合是否包含指定的value
        System.out.println(map.containsValue(2));

        //清空集合
        //map.clear();

        //获取map集合的key集合
        map.keySet();
        //获取集合的所有value值
        map.values();
        //遍历集合
        Set<String> keys = map.keySet();
        for(String  key : keys){
            System.out.println("key = " + key + ",value = " + map.get(key));
        }
        //通过map.entrySet();进行遍历
        Set<Map.Entry<String,Integer>> entrys = map.entrySet();
        for (Map.Entry<String,Integer> en : entrys){
            System.out.println("key = " + en.getKey() + ",value = " + en.getKey());
        }
    }
}

 

　　6.HashMap和Hashtable

　　（1）HashMap和Hashtable是Map接口的两个典型实现；

　　（2）区别：Hashtable一个古老的集合的Map实现类；Hashtable是一个线程安全的Map实现；Hashtable不允许使用nul作为key和value；

　　（3）Hashtable和HsahMap不能保证其中key-value对的顺序；

　　（4）Hashtable、HashMap判断两个Key相等的标准是：两个Key通过equals方法返回true，hashCode值也相等；

 

　　7.TreeMap

　　（1）和TreeSet一样，可以根据Key对key-value对进行排序，TreeMap可以保证所有的key-value对处于有序状态；

　　（2）和TreeSet一样，同样是分为自然排序和定制排序；

        Map<Integer,String> map = new TreeMap<Integer,String>();
        map.put(4,"d");
        map.put(3,"c");
        map.put(1,"a");
        map.put(2,"b");
        System.out.println(map);

        //自然排序使用的是英文字典排序
        Map<String,String> map1 = new TreeMap<String,String>();
        map1.put("aa","d");
        map1.put("ac","c");
        map1.put("c","a");
        map1.put("ab","b");
        map1.put("10","a");
        map1.put("1","a");
        System.out.println(map1);