Java基础------集合框架知识点总结（二）

                                 第一个类     Set类
一、摘要。
1、Set是一个不包含重复元素的Collection。
2、Set允许包含null元素，但是只允许同一个Set集合中只包含有一个null元素。
3、Set是Collection接口的一个子接口。
4、Set的两个实现类HashSet和TreeSet.
5、Set接口的定义如下：
6、Set集合的功能和Collection是一致的。

public interface Set<E> extends Collection<E>

一、HashSet类。
1、概述。
1）此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。
2）可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。
2、构造函数摘要。
1）HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16。
2）HashSet(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的新 set。


示例一：

package 泛型;

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

/**
 * 
 * @author ZHANGYU
 *  |--Set:元素是无序的（存入和取出的顺序不一定一致），元素不可以重复，线程是非同步的
 *      |--HashSet:底层数据结构是哈希表
 *          HashSet是如何保证元素的唯一性呢？
 *              是通过元素的两个方法HashCode和equals来完成
 *              如果元素的HashCode相同，才会判断equals是否为true,
 *              如果元素的HashCode不同，不会调用equals
 *          注意：判断元素是否存在，以及删除等操作，依赖的方法是hashCode和equals方法
 *      |--TreeSet：可以对set集合中的元素自然排序
 *                  底层数据结构是二叉树
 *                  保证元素唯一性的一句：
 *                  compareTo方法return
 *          TreeSet排序的第一种方式：让元素自身具有比较性
 *          元素需要实现comparable接口，实现compareTo方法
 *          这种方式称为元素的自然顺序，也成为默认顺序
 *          
 *          TreeSet排序的第二种方式：
 *          当元素没有比较性时，或具备的比较性不是所需要的
 *          这时候就需要让集合自身具有比较性
 *          在集合初始化时就有了比较方式
 *  Set功能和Collection是一致的。
 */
public class setDemo {

    public static void main(String[] args){
        HashSet hs=new HashSet();
        hs.add("1");
        hs.add("2");
        hs.add("3");
        hs.add("3");
        Iterator it=hs.iterator();
        while(it.hasNext()){
            sop(it.next());
        }

    }
    private static void sop(Object obj) {
        // TODO Auto-generated method stub
        System.out.println(obj);
    }
}

示例二：

package 泛型;
/**
 * 保证集合中元素的唯一性。
 * 需求：
 * 1、向集合中存储对象元素。
 * 2、姓名，和年龄相同视为同一个元素。
 * 
 */
import java.util.HashSet;
import java.util.Iterator;
/*
 * 通过覆写hashCode函数和equals函数。
 * 来保证元素的唯一性。
 */
class person1{

    private String name;
    private int age;
    public person1(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge()
    {
        return age;
    }
    //覆盖其hashCode函数
    public int hashCode(){

        return this.name.hashCode()+age*27;

    }
     public boolean equals(Object obj){
            if(!(obj instanceof person1))
                return false;
            person1 p=(person1)obj;
            return this.name.equals(p.getName())&&this.age==p.getAge();
        }
}
public class setDemo1 {

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args){
        //建立集合对象
        HashSet hs=new HashSet();
//      向集合中添加元素
        hs.add(new person1("1",23));
        hs.add(new person1("2",25));
        hs.add(new person1("4",45));
        hs.add(new person1("4",45));
        hs.add(new person1("6",24));
        hs.add(new person1("6",24));
        //遍历元素。
        Iterator it=hs.iterator();
        while(it.hasNext()){
            person1 p=(person1) it.next();
            sop(p.getName()+"::"+p.getAge());
        }

    }
}

二、TreeSet类。
1、概述。
1）此类实现了Set接口和SortedSet接口。
2）此类使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造。
2、构造函数概述。
1）TreeSet() 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
2）TreeSet(Collection<? extends E> c) 构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
3）TreeSet(Comparator<? super E> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。
示例：

package 泛型;
/*
需求
1、存储对象元素
2、给其赋予比较性，使其进行比较。
*/
import java.util.Iterator;
import java.util.TreeSet;
class Student implements Comparable{
    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    //覆写compareTo函数，按照指定的比较性进行排序
    public int compareTo(Object obj) {
        // TODO Auto-generated method stub
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生类");
        Student s=(Student)obj;
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
            return this.name.compareTo(s.getName());
        return -1;
    }

}
public class TreeSetDemo1 {

    public static void main(String[] args){
        TreeSet ts=new TreeSet();
        ts.add(new Student("abc",23));
        ts.add(new Student("abg",25));
        ts.add(new Student("adc",32));
        ts.add(new Student("sbc",43));
        ts.add(new Student("afc",43));
        Iterator it=ts.iterator();
        while(it.hasNext()){
            Student s=(Student)it.next();
            System.out.println(s.getName()+"::"+s.getAge());
        }

    }
}

                                 第二个类     Map类

一、概述。
1、Map<K,V>可用于保存具有映射关系的数据。
2、一个映射不能包含重复的键；每个键最多只能映射到一个值。
3、Map<K,V>接口的实现如下：

    public interface Map<K,V>

二、Map集合的简介。
1、方法。
1） 存
* V put(K key, V value) 添加元素如果存入相同的键，他会覆盖先存入的值，并且返回被覆盖的那个值

void putAll(Map<? extends K,? extends V> m) 

2 ）删。
void clear()
remove(Object key)
3） 判断。
containsKey(Object key)
containsValue(Object value)
isEmpty()

4 ）获取。
get(Object key ）
size()
values()

entrySet()
keySet()
2、Map的子类。
Map
 |—Hashtable:底层是哈希表数据结构，不可以存入null键和null值。该集合线程同步，jdk1.0 效率低。
  |—HashMap:底层是哈希表数据结构，可以存入null键和null值。该集合线程不同步，jdk1.2 效率高。
     |—TreeMap:底层是二叉树数据结构，线程不同步，可以给集合中的键进行排序。
和Set很像，其实set底层就是使用了map集合。
示例一：

package 泛型;
/*
Map集合的一些基本方法演示。
*/
import java.util.HashMap;
import java.util.Map;

public class MapTest1 {

    public static void main(String[] args){
        Map<String,String> map=new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("02", "lisi1");

        map.put("03", "wangwu");
        map.put("04", "zhaoliu");
        System.out.println("1"+map);

        System.out.println("2"+map.get("01"));
        System.out.println("3"+map.remove("01"));
        System.out.println("4"+map);
        System.out.println("5"+map.containsKey("01"));
        System.out.println("6"+map.containsValue("lisi"));
        System.out.println("7"+map);
        System.out.println("8"+map.put("02", "lisi"));
        System.out.println("9"+map);


    }
}

HashMap类
一、概述。
1、此类实现了Map集合，对元素的添加和删除具有较高的效率。
2、此类提供了所有可选的映射操作，并且允许使用null值和null键，但必须保证键的唯一性。
3、此类是非同步的类，同时也不保证映射顺序。
二、构造函数摘要。
1、HashMap() 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
2、HashMap(Map<? extends K,? extends V> m)构造一个映射关系与指定 Map 相同的新 HashMap。

示例一：

package 泛型;

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

/*取出演示：
 * entrySet()
 * 
 * keySet()：返回map集合存入到set集合中，通过set迭代器取出所有的键，之后通过map的get方法获取值
 */
public class MapTest2 {
    public static void main(String[] args){
        Map<String,String> map=new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("02", "lisi1");
        map.put("03", "wangwu");
        map.put("04", "zhaoliu");
        //第一种
//      Set<String> key=map.keySet();
//      Iterator<String> it=key.iterator();
//      while(it.hasNext()){
//          String obj=it.next();
//          System.out.println(obj+"::"+map.get(obj));
//      }
        //第二种
        Set<Entry<String,String>> en=map.entrySet();
        Iterator<Entry<String,String>> it=en.iterator();
        while(it.hasNext()){
            Entry<String,String> e=it.next();
            System.out.println(e.getKey()+"::"+e.getValue());
        }
    }   
}

示例二：

package 泛型;
/*每个学生都有对应的归属地，
 * 学生：student11 地址String
 * 学生属性：姓名、 年龄
 * 注意：姓名和年龄相同视为同一个学生
 * 保证学生的唯一性
 * 
 * 
 */
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

class student11 implements Comparable<student11>{
    private String name=null;
    private int age=0;
    public student11(String name, int age) {
        this.setName(name);
        this.setAge(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;
    }
    public  int hashCode(){
        return name.hashCode()+age*27;
    }
    public boolean equals(Object obj){
        if(!( obj instanceof student11))
            return false;
        student11 s=(student11)obj;
        return this.name.equals(s)&&this.getAge()==age;
    }
    @Override
    public int compareTo(student11 s) {
        // TODO Auto-generated method stub
        int num=new Integer(this.age).compareTo(new Integer(s.getAge()));
        if(num==0)
            return this.name.compareTo(s.getName());
        return num;
    }
    public String toString(){
        return this.name+"::"+this.age;
    }


}

public class MapTest3 {

    public static void main(String[] args){
        HashMap<student11,String> map=new HashMap<student11,String>();
        map.put(new student11("dzhangsan",21), "beijing");
        map.put(new student11("slisi",23), "tianjin");
        map.put(new student11("xwangwu",25), "shandong");
        map.put(new student11("vzhaoliu",26), "shanghai");
        map.put(new student11("wancai",27), "anhui");
        //第一种取出方式。
        Set<student11> keyset=map.keySet();
        Iterator<student11> it=keyset.iterator();
        while(it.hasNext()){
            student11 s=it.next();
            System.out.println(s.getName()+"::"+s.getAge()+"::"+map.get(s));
        }

        //第二种取出方式
        System.out.println();
        Set<Entry<student11,String>> entry=map.entrySet();
        Iterator<Entry<student11,String>> it1=entry.iterator();
        while(it1.hasNext()){
            Entry<student11,String> en=it1.next();
            student11 s=en.getKey();
            String add=en.getValue();
            System.out.println(s+"::"+add);

        }
    }
}

TreeMap类
一、概述。
   该类映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
二、构造函数摘要。
1、TreeMap() 使用键的自然顺序构造一个新的、空的树映射。
2、TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序。
3、TreeMap(Map<? extends K,? extends V> m) 构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序 进行排序。
示例一：

package 泛型;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

class stuNameComparator implements Comparator<student11>{

    public stuNameComparator(){

    }
    //根据姓名进行排序。
    public int compare(student11 o1, student11 o2) {
        // TODO Auto-generated method stub
        int num=o1.getName().compareTo(o2.getName());
        if(num==0)
            return new Integer(o1.getAge()).compareTo(o2.getAge());
        return num;
    }

}
public class TreeMapTest1 {
    public static void main(String[] args){
        TreeMap<student11,String> tm=new TreeMap<student11,String>(new stuNameComparator());
        tm.put(new student11("zhangsan",21), "beijing");
        tm.put(new student11("lisi",23), "tianjin");
        tm.put(new student11("wangwu",56), "shandong");
        tm.put(new student11("zhaoliu",26), "shanghai");
        tm.put(new student11("wancai",73), "anhui");
        tm.put(new student11("a",75), "anhui");
        Set<Entry<student11,String>> entry=tm.entrySet();
        Iterator<Entry<student11,String>> it=entry.iterator();
        while(it.hasNext()){
            Entry<student11, String> s=it.next();
            System.out.println(s.getKey()+":"+s.getValue());
        }

    }
}

示例二：

“`
package 泛型;
/*
* 1.练习
* “adcdswe”获取字符串中的字母，并且算出字母出现的次数
* a(1)
* d(1)
*

• 
  
  • */
    import java.util.Iterator;
    import java.util.Map.Entry;
    import java.util.Set;
    import java.util.TreeMap;

public class TreeMapTest2 {

public static void main(String[] args){
    charCount("abcedaadadasdsddsdgdsdf");
}
public static void charCount(String str){
    char[] ch=str.toCharArray();
    TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
    for(int i=0;i<ch.length;i++){
        boolean flage=tm.containsKey(ch[i]);
        if(flage==true){
            int count=tm.get(ch[i]);
            count++;
            tm.put(ch[i], count);
        }
        else{
            tm.put(ch[i], 1);
        }
    }
    Set<Entry<Character,Integer>> entry=tm.entrySet();
    Iterator<Entry<Character,Integer>> it=entry.iterator();
    while(it.hasNext()){
        Entry<Character,Integer> en=it.next();
        System.out.println(en.getKey()+"("+en.getValue()+")");
    }
}

}