0基础学java之Day25

Vector

 /** 知识点：Vector独有的方法
      理解：
     *         Vector在JDK1.0开始就已经存在 -- 元老级别的集合类，
     *         集合框架的概念是JDK1.2开始才有的，
     *         开发人员为了将Vector保留下来，让其多实现了List接口
     * 
     * 注意：
     *         Vector底层的数据结构和ArrayList是一样的 -- Object类型的一维数组
     *         Vector底层方法加锁，该类是线程安全的，多线程的情况下使用
     */
    public static void main(String[] args) {
        
        Vector<String> v = new Vector<>();
        
        //添加元素
        v.addElement("aaa");
        v.addElement("bbb");
        v.addElement("ccc");
        v.addElement("ddd");
        v.addElement("eee");
        
        v.removeElementAt(1);//根据下标删除元素
        v.removeElement("ccc");//根据元素删除元素
        
        //遍历元素
        Enumeration<String> elements = v.elements();
        while(elements.hasMoreElements()){
            String element = elements.nextElement();
            System.out.println(element);
        }
    }
 

Stack

//知识点：Stack独有的方法
     * 继承关系：Stack -> Vector
     * 特点：栈模式 - 先进后出
     */
    public static void main(String[] args) {
        
        Stack<String> stack = new Stack<>();
        
        //将元素添加到栈顶
        stack.push("小红");
        stack.push("小黄");
        stack.push("小绿");
        stack.push("小蓝");
        stack.push("小紫");
        
        //获取栈顶元素
        String peek = stack.peek();
        System.out.println("获取栈顶元素：" + peek);
        
        //从1开始数
        System.out.println("获取该元素距离栈顶的位置：" + stack.search("小紫"));
        
        //栈模式
        while(!stack.empty()){//判断集合中是否有元素
            
            String pop = stack.pop();//删除栈顶元素，并返回
            System.out.println(pop);
        }
        
    }

Set接口

所有的Set集合有一个共同特征：元素不可重复。

Set集合的实现类有很多，常见的有3个：HashSet、LinkedHashSet、TreeSet。

Set接口的方法都是从Collection继承的，直接使用刚刚学过的Collection的方法即可。

HashSet

• 理解 - 无序：存入顺序与取出顺序不一致，无序不代表随机

• 特点：无序且不可重复 -- 去重

• 存入顺序：

  1.获取元素的hash值 -- hashCode() ​ 2.利用hash值计算在数组中下标 ​ 3.判断下标上是否有元素 ​ 3.1 - 没有元素，直接添加 ​ 3.2 - 有元素，判断两个元素是否相同 ​ 判断的准则：hash值 && (== || equals) ​ 3.2.1 - 不相同，添加数据，形成单向链表 ​ （JDK1.7-头插法，JDK1.8尾插法） ​ 3.2.2 - 相同，就不添加数据 -- 达到去重的效果 ​ 取出顺序：数组顺序

  HashSet为什么无序？ 答：存入顺序的逻辑和取出顺序的逻辑不一致

LinkedHashSet

• 特点：有序且不可重复 -- 去重

• 存入顺序和父类HashSet的逻辑90%是一样的

• 取出顺序：遍历的是双向链表

TreeSet

* 知识点：TreeSet的特点
     * 
     * 特点：自然排序、去重
     * 理解：TreeSet会根据不同的数据类型选择不同的排序规则
     */
    public static void main(String[] args) {
        
        //TreeSet存储Integer：数字升序
        TreeSet<Integer> set1 = new TreeSet<>();
        set1.add(8);
        set1.add(1);
        set1.add(5);
        set1.add(6);
        set1.add(3);
        for (Integer element : set1) {
            System.out.println(element);
        }
        
        System.out.println("----------------------------------");
        
        //TreeSet存储String：字典排序
        TreeSet<String> set2 = new TreeSet<>();
        set2.add("b");
        set2.add("bc");
        set2.add("bb");
        set2.add("v");
        set2.add("c");
        set2.add("a");
        for (String element : set2) {
            System.out.println(element);//a b bb bc c v 
        }
    }

TreeSet与HashSet的区别？

TreeSet：会按照元素的大小顺序排列，一定会用到比较器，默认找Comparable接口的compareTo方法。凡是要放到TreeSet集合里面的元素类型必须实现Comparable接口，重写compareTo方法。

• TreeSet认为的元素重复，是看compareTo方法是不是返回0，如果是0，就是重复元素。不是0，就不重复。

• HashSet认为的元素重复，是看equals方法是否返回true，返回true为重复否则不重复。

  前提：重写equals时，通常都要重写hashCode方法。因为Java中有一个常规协定，如果两个对象hashCode值不一样，就无须看它们的equals方法，因为hashCode值不一样，就默认为equals一定false。如果两个对象的hashCode值一样，再看equals方法，是不是返回true，如果是true，就是重复，不是true，就不重复。

Map接口

HashMap的常用方法

public static void main(String[] args) {
            HashMap<String, Integer> map = new HashMap<>();
            /**
             * 添加元素：如果是第一次添加该key就返回null
             * 如果有重复的key就替换老的value并返回
             */
            Integer put1 = map.put("小红", 111);
            System.out.println(put1);//null
            map.put("小黄", 222);
            map.put("小绿", 333);
            map.put("小蓝", 444);
            map.put("小紫", 555);
            Integer put2 = map.put("小黄", 666);
            System.out.println(put2);//222
            
            //通过key获取value
            System.out.println(map.get("小红"));//111
            
            //如果key存在，获取对应的value；否则返回默认值
            System.out.println(map.getOrDefault("aaa", 888));//aaa不存在返回888
            
            //清空集合数据
            //map.clear();
            
            System.out.println("判断map集合中是否有指定的key：" + map.containsKey("小紫"));//true
            System.out.println("判断map集合中是否有指定的value：" + map.containsValue(555));//true

            System.out.println("判断集合中是否没有元素：" + map.isEmpty());//false
            
            //将newMap1中所有的元素添加到map中
            HashMap<String, Integer> newMap1 = new HashMap<>();
            newMap1.put("aaa", 10);
            newMap1.put("bbb", 20);
            newMap1.put("ccc", 30);
            map.putAll(newMap1);

            //如果有key就获取对应的value；否则就添加元素
            Integer putIfAbsent1 = map.putIfAbsent("小绿", 22);
            System.out.println("putIfAbsent1：" + putIfAbsent1);//333
            Integer putIfAbsent2 = map.putIfAbsent("ddd", 22);
            System.out.println("putIfAbsent2：" + putIfAbsent2);//null

            //通过key删除数据，返回value值
            Integer remove1 = map.remove("aaa");
            
            //通过key+value删除数据，返回boolean（删除是否成功）
            System.out.println("remove1：" + remove1);//10
            boolean remove2 = map.remove("bbb", 20);
            System.out.println("remove2：" + remove2);//true

            //通过key替换value
            Integer replace1 = map.replace("ccc", 40);
            System.out.println("replace1：" + replace1);//30
            boolean replace2 = map.replace("ccc", 40, 50);
            //通过key+value替换value，返回boolean（替换是否成功）
            System.out.println("replace2：" + replace2);//true

            //获取映射关系个数（理解映射关系：key+value）
            int size = map.size();
            System.out.println("获取元素的个数：" + size);//7

            //获取map集合中所有的value，返回Collection集合
            Collection<Integer> values = map.values();
            System.out.println(values);
            //更专业写法
            //System.out.println("获取map集合中所有的value：" + Arrays.toString(values.toArray()));
            
            System.out.println("--------------------");
            
            //遍历集合 -- keySet()
            //遍历思路：通过map.keySet()获取该key的Set集合，遍历Set集合循环取出key，再使用map.get(key)获取对应的value
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
                Integer value = map.get(key);
                System.out.println(key+"--"+value);
            }
            
            System.out.println("--------------------");
            
            //遍历集合 -- entrySet()
            Set<Entry<String,Integer>> entrySet = map.entrySet();
            for (Entry<String, Integer> entry : entrySet) {
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key+"--"+value);
                //也可以直接输出entry
                //System.out.println(entry);
            }    
            
        }

特点：

1.HashMap的key不允许重复

2.HsahMap的value允许重复

3.完全无序，线程不安全

   4.支持key，value为null

LinkedHashMap

特点：

1.HashMap的key不允许重复

2.HsahMap的value允许重复

3.有序，线程不安全

   4.支持key，value为null

TreeMap

特点：

1.HashMap的key不允许重复

2.HsahMap的value允许重复

3.有序，线程不安全

   4.不支持key，value为null

内置比较器和外置比较器区别：

1.定义位置：

         内置比较器：将比较逻辑定义在类内部，即让类实现Comparable接口，并重写compareTo方法。

        外置比较器：将比较逻辑定义在类外部，即创建一个新的比较器类实现Comparator接口，并重写compare方法。

2.灵活性：

         内置比较器：一个类一旦实现了Comparable接口，就固定了一种排序逻辑，不便于后续更改或添加多种排序方式。

        外置比较器：可以针对同一个类创建多个不同的比较器，实现多种排序逻辑，更加灵活。

3.使用场景：

        内置比较器：适用于类的自然排序或默认排序。例如，String、Integer等Java内置类都实现了Comparable接口，提供了默认的排序规则。

外置比较器：适用于需要对已有类进行自定义排序或多种排序需求的场景。例如，对学生信息按照姓名、年龄、成绩等不同字段进行排序。

Hashtable

特点：

1.Hashtable的key不允许重复

2.Hsahtable的value允许重复

3.无序，线程安全

4.不支持key，value为null

被ConcurrentHashMap淘汰

ConcurrentHashMap

特点：

1.Hashtable的key不允许重复

2.Hsahtable的value允许重复

   3.无序，线程安全(局部加锁，效率高)

Properties

在src下面创建一个File文件dbconfig.properties内容为：username=root password=201028

public static void main(String[] args) throws IOException {
        
        //创建配置文件类的对象
        Properties properties = new Properties();
        
        //将配置文件加载到配置文件对象中
        properties.load(Test01.class.getClassLoader().getResourceAsStream("dbconfig.properties"));
        
        //通过配置文件对象去获取配置文件里的数据
        String username = properties.getProperty("username");
        String password = properties.getProperty("password");
        System.out.println(username + " -- " + password);
    }