黑马程序员---2015.6.21.java基础笔记---TreeSet---HashSet---HashMap

最新推荐文章于 2020-04-10 02:02:20 发布

月满西楼_qd

最新推荐文章于 2020-04-10 02:02:20 发布

阅读量394

点赞数

分类专栏： java基础笔记文章标签： TreeSet HashSet Hash

本文链接：https://blog.csdn.net/u010870544/article/details/46584599

版权

java基础笔记专栏收录该内容

22 篇文章 0 订阅

订阅专栏

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.TreeSet:可以对set集合中的元素进行排序，没有重复元素且有序！

                   自定义对象，必须实现Comparable接口，重写compareTo(T o) 方法
                   底层数据结构是二叉树。
                   保证元素唯一性的依据是：compareTo方法return 0.

                   TreeSet排序的第一种方式：让元素自身具备比较性。
                   元素需要实现Comparable接口，覆盖compareTo方法。
                   这种方式也成为元素的自然顺序，或者叫做默认顺序。


   HashSet:自定义对象，必须重写hashCode和equals方法
2.当元素自身不具备比较性，或者具备的比较性不是所需的。
   这时需要让容器自身具备比较性。
   定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数

   当两种排序都存在时，以比较器为主。
   定义一个类，实现Comparator接口，覆盖compare方法

3.TreeSet自身具备比较性的示例。
   /

*
        按字符串的长度进行排序
            1.TreeSet自身具备比较器
            2.使用泛型
    */
    import java.util.*;
    class TreeSetTest
    {
            public static void main(String[] args)
            {
                TreeSet<String> ts = new TreeSet<String>(new StrLengthComparator());
                ts.add("abcd");
                ts.add("cc");
                ts.add("cba");
                ts.add("aaa");
                ts.add("z");
                ts.add("hahaha");
                
                Iterator<String> it = ts.iterator();
                while(it.hasNext())
                {
                    String s = it.next();
                    System.out.println("s:"+s);
                }
    
            }
    }
    
    class    StrLengthComparator implements Comparator<String>
    {
        //所有的s1 和 s2调换一下，就会变成从大到下的输出
        public int compare(String s1, String s2)
        {
            int num = s1.length() - s2.length();
            if(num == 0)
                return s1.compareTo(s2);
            return num;    
        }
    }

4.泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。
       好处！
           a.将运行时期的问题ClassCastException,转移到了编译时期。
               方便于程序员解决问题，让运行时期问题减少，安全。
           b.避免了强制转化的麻烦。
       泛型格式：通过<>来定义要操作的引用类型
       在使用java提供的对象时，什么时候写泛型呢？
               通常在集合框架中很常见。
               只要见到<>就要定义泛型。
               其实<>就是用来接收类型的。
               当使用集合时，将集合中要存储的数据类型，作为参数传递到<>即可
5.什么时候定义泛型？
       当类中要操作的引用数据类型不确定的时候。
6.   泛型类定义的泛型，在整个类中有效。如果被方法使用，
       那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
       为了让不同方法可以操作不同类型，而且类型还不确定。
       那么可以将泛型定义在方法上。

       特殊之处：
       静态方法不可以访问类上定义的泛型。
       如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

  class Demo<T>
        {
            public void show(T t){
                System.out.println(t);
            }
        }    
        
        class Demo
        {
            public <T> void show(T t){
                System.out.println(t);
            }
            
            public static <Q> void print(Q q){
                System.out.println(q);
            }
        }

7. ？通配符，也可以理解为占位符。
   泛型限定：？extends E：可以接收E类型或者E类型的子类型。上限。
                          ？super R: 可以接收R类型或者R类型的父类型，下限。

8.Map集合
       ---Hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步
       ---HashMap：底层是哈希表数据结构，可以存入null键null值，该集合是不同步的
       ---TreeMap：底层是二叉树数据结构，线程不同步，可以用于给map集合中的键值进行排序。
   和Set很像。
   其实Set底层就是使用了Map集合
10.map集合的两种取出方式
   --1.Set<K> keySet   将map中所有的键存入到Set集合，因为Set具备迭代器。
                                          所有可以迭代方式取出所有的键值，再根据get方法，获取每一个键对应的值

                                           Map集合取出原理：将map集合转成set集合，再通过迭代器取出

   --2.Set<Map.Entry<K,V>>entrySet   ；将map集合中的映射关系取出，   存入到Set集合中
           Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。

/*
    如果添加元素的键一样，值不一样，那么新存入的将覆盖原来的
    put方法会返回本键原来的值value
*/
import java.util.*;
class MapDemo
{
    public static void main(String[] args)
    {
        Map<String,String> map = new HashMap<String,String>();
        //添加元素
        map.put("01","zhangsan1");
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");
        map.put("04","zhangsan4");
        
        
        //将Map集合中的映射关系取出来，放入Set集合
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        Iterator<Map.Entry<String,String>> it = entrySet.iterator();
        while(it.hasNext())
        {
            Map.Entry<String,String> me = it.next();
            sop("key="+me.getKey()+";"+"value="+me.getValue());
        }
    }
    
    public static void sop(Object o)
    {
        System.out.println(o);
    }
    
    public static void method()
    {
        Map<String,String> map = new HashMap<String,String>();
        //添加元素
        map.put("01","zhangsan");
        map.put("02","zhangsan");
        map.put("02","zhangsan2");
        sop(map.put("02","zhangsan25"));
        
        sop("containsKey:"+map.containsKey("02"));
        
        //sop("remove:"+map.remove("02"));
        sop("get:"+map.get("05"));
        
        map.put("03",null);
        
        //获取map集合中所有的值
        Collection<String> coll = map.values() ;
        sop("map中所有的值："+coll);
        sop(map);    
    }
    
    public static void method_keySet()
    {
        Map<String,String> map = new HashMap<String,String>();
        //添加元素
        map.put("01","zhangsan1");
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");
        map.put("04","zhangsan4");
        //先获取map集合的所有键的Set集合
        Set<String> keySet = map.keySet();
        //获取迭代器
        Iterator<String> it = keySet.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            String value = map.get(key);
            sop("key:"+key+ "  value"+value);
        }
            
    
    }
}