精华内容
下载资源
问答
  • 前言 说起来开始进行面试是11月倒数第二... 完整版获取:狂戳这里免费领取~ 《Java高级面试》 《Java高级架构知识》 《算法知识》 《Java高级架构知识》 [外链图片转存中…(img-QAKyhts6-1621480155844)] 《算法知识》

    前言

    说起来开始进行面试是11月倒数第二周,上午9点,我还在去公司的公交上,突然收到蚂蚁的面试电话,其实算不上真正的面试。面试官只是和我聊了下他们在做的事情(主要是做双十一这里大促的稳定性保障,偏中间件吧),说的很详细,然后和我沟通了下是否有兴趣,我表示有兴趣,后面就收到正式面试的通知,最后没选择去蚂蚁表示抱歉。

    当时我自己也准备出去看看机会,顺便看看自己的实力。当时我其实挺纠结的,一方面现在部门也正需要我,还是可以有一番作为的,另一方面觉得近一年来进步缓慢,没有以前飞速进步的成就感了,而且业务和技术偏于稳定,加上自己也属于那种比较懒散的人,骨子里还是希望能够突破现状,持续在技术上有所精进。

    进入正题,先后进行了蚂蚁、拼多多和字节跳动的面试。

    第一章 成局在胸一一用工具对 SQL 整体优化

    第二章 风驰电掣一一有效缩短SQL 优化过程

    第三章规蹈矩一一如何读懂SQL 执行计划

    第四章 运筹幢幢一一左右 SQL执行计划妙招

    第五章感受体系结构让SQL飞

    第六章 且慢,体验逻辑结构让SQL飞

    第七章探寻表的设计让SQL飞

    第八章学习索引如何让SQL飞

    第九章弄清索引之阻碍让SQL飞

    第十章真他索引应用让SQL飞

    第十一章表连接的秘密让SQL飞

    第十二章动手,过程函数优化让SQL飞

    最后

    分享一些资料给大家,我觉得这些都是很有用的东西,大家也可以跟着来学习,查漏补缺。

    完整版获取:狂戳这里免费领取~

    《Java高级面试》

    《Java高级架构知识》

    《算法知识》

    《Java高级架构知识》

    [外链图片转存中…(img-QAKyhts6-1621480155844)]

    《算法知识》

    展开全文
  • Java容器集合的区别用法:http://www.cnblogs.com/sunliming/archive/2011/04/05/2005957.html 参见:http://dafeng.wang.blog.163.com/blog/static/1281691932009109115513940/ import java.lang.Str...

    Java容器集合类的区别用法: http://www.cnblogs.com/sunliming/archive/2011/04/05/2005957.html 

    参见:http://dafeng.wang.blog.163.com/blog/static/1281691932009109115513940/

    复制代码
    import java.lang.String;
    import java.util.*;
    
    public class JAVAContainer {
    
        // Interfaces:
        // Interface Iterator: hasNext(),  next(), remove() ---- 所有容器通用的遍历方式。
        // Interface Collection:add(E e),remove(Object o), clear(), isEmpty(), size(), iterator(), toArray() ---- 所有单值容器(map除外)的公共接口。 
        // Interface Map: put(K key, V value), get(Object key), remove(Object key), clear(),isEmpty(),size(), keySet(), entrySet(), values()  ---- 所有K-V容器的公共接口,常见class: HashMap, Hashtable, IdentityHashMap, LinkedHashMap, ConcurrentHashMap
        // Interface Map.Entry: getKey(), getValue(), setValue(V value) ---- 用于遍历Map容器。
        //
    
        public static void main(String[] args) throws Exception {
            // ArrayList
            {
                ArrayList arraylist = new ArrayList();
                arraylist.add(0, "end");//指定索引加入值
                // 需注意的是,如果现有2个值,我加入索引为5的那么就会出现异常
                for (int i = 0; i < 2; i++) {
                    arraylist.add(i, String.valueOf(i));
                }
                System.out.println("ArrayList:");
                for (int i = 0; i < arraylist.size(); i++) {
                    System.out.print(arraylist.get(i) + ";");
                }
    
                arraylist.add("0");//直接加入值到ArrayList的最后
                arraylist.add("0");
                System.out.println("");
                System.out.print(" ArrayList's lastIndexOf(\"0\") is " + arraylist.lastIndexOf("0")); 
    
                for (Object val : arraylist) {
                    System.out.print( val + ";");
                }
                System.out.println("\n");
            }
    
            // Arrays
            {
                String[] array = new String[] { "a", "b", "c" };
                List list = Arrays.asList(array);
                System.out.println(" Arrays:");
                for (int i = 0; i < list.size(); i++) {
                    System.out.print(list.get(i) + ";");
                }
                System.out.print(" Arrays's length is " + array.length);//打印数组的长度
                
                System.out.println("");
                for (Object val : array) {
                    System.out.print( val + ";");
                }
                System.out.println("\n");
            }
    
            // Collections
            {
                String[] array = new String[] { "a", "b", "c" };
                List list = Arrays.asList(array);
                Collections.fill(list, "Fill");//用Fill填充全部元素
                System.out.println(" Collections:");
                for (int i = 0; i < list.size(); i++) {
                    System.out.print(list.get(i) + ";");
                }
                array = new String[] { "1", "2", "3" };
                List list2 = Arrays.asList(array);
                Collections.copy(list, list2);//拷贝list2的数据进list
                System.out.println(" " + list);
                Collections.swap(list, 2, 1);//调换索引为1和2的元素的位置
                System.out.println(list);
                System.out.println("\n");
            }
    
            // EventObject
            {
                String s = "hello";
                String s2 = s;
                EventObject eventobject = new EventObject(s);//一个准容器类型,确切的归类它不是容器
                System.out.println("EventObject:");
                System.out.println(eventobject.getSource());
                System.out.println(eventobject.equals(s2));
                System.out.println("\n");
            }
    
            // HashMap
            {
                HashMap hashmap = new HashMap();//一个速度最快的容器
                hashmap.put("0", "c");
                hashmap.put("1", "a");
                hashmap.put("2", "b");
                hashmap.put("3", "a");
    
                System.out.println("HashMap:");
                System.out.println(hashmap);//该容器有其内部的排序方式
                Set set = hashmap.keySet();//获取全部键
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
                    System.out.print(hashmap.get(iterator.next()) + ";");
                }
                System.out.println("");
    
                System.out.println("HashMap: K-V");
                iterator = set.iterator();
                while (iterator.hasNext()) {
                    Object key = iterator.next();
                    System.out.print(key+":"+hashmap.get(key) + ";");
                }
                System.out.println("");
    
                System.out.println("HashMap(Entry): K-V");
                Set<Map.Entry> kvSet = hashmap.entrySet();
                Iterator<Map.Entry> it = kvSet.iterator();
                while (it.hasNext()){
                    Map.Entry entry = it.next();
                    System.out.print( entry.getKey()+":" + entry.getValue() +";");
                } 
    
                System.out.println("\n");
            }
    
            // HashSet
            {
                HashSet hashset = new HashSet();//一个绝对不能重复的类型
                hashset.add("c");
                hashset.add("b");
                hashset.add("a");
                hashset.add("a");
                hashset.add("b");
                System.out.println(" HashSet:");
                System.out.println(hashset);
                Iterator iterator = hashset.iterator();//取出元素
                while (iterator.hasNext()) {
                    System.out.print(iterator.next() + ";");
                }
                System.out.println("\n");
            }
    
            // Hashtable
            {
                Hashtable hashtable = new Hashtable();//一个完全可以由其他容器替换的老容器类型
                hashtable.put("0", "c");
                hashtable.put("1", "a");
                hashtable.put("3", "c");
                hashtable.put("2", "b");
                System.out.println(" Hashtable:");
                Enumeration enumeration = hashtable.elements();//获取元素,Enumeration已经不是主流,Iterator是它的下一代替代品
                while (enumeration.hasMoreElements()) {
                    System.out.print(enumeration.nextElement() + ";");
                }
                System.out.println("\n");
            }
    
            // IdentityHashMap
            {
                IdentityHashMap identityhashmap = new IdentityHashMap();
                identityhashmap.put("0", "c");
                identityhashmap.put("1", "a");
                identityhashmap.put("3", "b");
                identityhashmap.put("2", "a");
                System.out.println(" IdentityHashMap:");
                System.out.println(identityhashmap);
                System.out.println(identityhashmap.containsKey("3"));//是否包含这个键
                System.out.println(identityhashmap.containsValue("a"));//是否包含值
                Set set = identityhashmap.entrySet();//传为Set类型
                System.out.println(set);
                set = identityhashmap.keySet();//全部键
                System.out.println(set);
                System.out.println("\n");
            }
    
            // LinkedHashMap
            {
                LinkedHashMap linkedhashmap = new LinkedHashMap();
                linkedhashmap.put("0", "b");
                linkedhashmap.put("2", "a");
                linkedhashmap.put("1", "c");
                linkedhashmap.put("3", "b");
                System.out.println("LinkedHashMap:");
                System.out.println(linkedhashmap);
                System.out.println(linkedhashmap.containsKey("2"));//是否包含这个键
                System.out.println(linkedhashmap.containsValue("c"));//是否包含值
                Set set = linkedhashmap.keySet();
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
                    System.out.print(linkedhashmap.get(iterator.next()) + ";");
                }
                System.out.println("\n");
            }
    
            // LinkedHashSet
            {
                LinkedHashSet linkedhashset = new LinkedHashSet();//它包含了几种Set的属性但却没有自己的特色
                linkedhashset.add("c");
                linkedhashset.add("a");
                linkedhashset.add("a");
                linkedhashset.add("b");
                System.out.println(" LinkedHashSet:");
                System.out.println(linkedhashset);
                System.out.println(linkedhashset.contains("a"));//是否包含对象
                Iterator iterator = linkedhashset.iterator();
                while (iterator.hasNext()) {
                    System.out.print(iterator.next() + ";");
                }
                System.out.println("\n");
            }
    
            // LinkedList
            {
                LinkedList linkedlist = new LinkedList();//自由使用是它的特色
                linkedlist.add("a");
                linkedlist.add(1, "c");
                linkedlist.addLast("b");
                linkedlist.addFirst("d");
                System.out.println(" LinkedList:");
                System.out.println(linkedlist);
                // linkedlist.clear();//该方法清空容器
                // linkedlist.remove(0);//删除索引为0的元素
                // linkedlist.remove("d");//删除值为d的元素
                // linkedlist.removeFirst();//删除第一个元素
                // linkedlist.removeLast();//删除最后一个元素
                for (int i = 0; i < linkedlist.size(); i++) {
                    System.out.print(linkedlist.get(i) + ";");
                }
                System.out.println("\n");
            }
    
            // Stack
            {
                Stack stack = new Stack();//堆栈
                stack.add("b");
                stack.add(0, "c");
                stack.push("d");
                stack.add("e");
                stack.push("a");
                Enumeration enumeration = stack.elements();
                System.out.println(" Stack:");
                while (enumeration.hasMoreElements()) {
                    System.out.print(enumeration.nextElement() + ";");
                }
                // 后进先出
                System.out.println(" " + stack.peek());
                System.out.println(stack.pop());
                System.out.println(stack.contains("d") + ";" + stack.contains("a"));//是否包含该元素,有趣的事情发生了
                System.out.println(stack.search("c"));//非常有用的属性,检索,但是由后向前的排列
                System.out.println("\n");
            }
    
            // TreeMap
            {
                TreeMap treemap = new TreeMap();
                treemap.put("0", "d");
                treemap.put("2", "a");
                treemap.put("1", "b");
                treemap.put("3", "c");
                System.out.println(" TreeMap:");//可以对键排序
                System.out.println(treemap);
                System.out.println(treemap.firstKey());//返回第一个键
                Set set = treemap.keySet();
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
                    System.out.print(treemap.get(iterator.next()) + ";");
                }
                System.out.println("\n");
            }
    
            // TreeSet
            {
                TreeSet treeset = new TreeSet();//自动排序内容
                treeset.add("b");
                treeset.add("a");
                treeset.add("c");
                treeset.add("d");
                System.out.println(" TreeSet:");
                System.out.println(treeset);
                System.out.println(treeset.first());//返回第一个元素
                Iterator iterator = treeset.iterator();
                while (iterator.hasNext()) {
                    System.out.print(iterator.next() + ";");
                }
                System.out.println("\n");
            }
    
            // Vector
            {
                Vector vector = new Vector();
                vector.add(0, "b");
                vector.add("a");
                vector.addElement("d");
                vector.add("c");
                System.out.println(" Vector:");
                System.out.println(vector);
                vector.set(2, "h");//替换掉指定索引的元素
                System.out.println(vector);
                Object[] str = vector.toArray();
                for (int i = 0; i < str.length; i++) {
                    System.out.print(str[i] + ";");
                }
                vector.setSize(2);//重新设置大小为2
                System.out.println(" " + vector);
                System.out.println("\n");
            }
    
            // WeakHashMap
            {
                WeakHashMap weakhashmap = new WeakHashMap();
                weakhashmap.put("1", "b");
                weakhashmap.put("2", "c");
                weakhashmap.put("0", "d");
                weakhashmap.put("3", "a");
                System.out.println(" WeakHashMap:");
                System.out.println(weakhashmap);
                System.out.println(weakhashmap.containsKey("3"));//是否包含键
                System.out.println(weakhashmap.containsValue("d"));//是否包含值
                Set set = weakhashmap.entrySet();
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
                    System.out.print(iterator.next() + ";");
                }
                // weakhashmap.remove("2");//删除该键对应的值
                // weakhashmap.get("1");//获取指定键的值
                System.out.println("\n");
            }
        }
    }

       ,如需转载请自行联系原作者

    展开全文
  • Java容器集合的区别用法: http://www.cnblogs.com/sunliming/archive/2011/04/05/2005957.html  参见:http://dafeng.wang.blog.163.com/blog/static/1281691932009109115513940/ import java.lang.String;...

    Java容器集合类的区别用法: http://www.cnblogs.com/sunliming/archive/2011/04/05/2005957.html 

    参见:http://dafeng.wang.blog.163.com/blog/static/1281691932009109115513940/

    import java.lang.String;
    import java.util.*;
    
    public class JAVAContainer {
    
        // Interfaces:
        // Interface Iterator: hasNext(),  next(), remove() ---- 所有容器通用的遍历方式。
        // Interface Collection:add(E e),remove(Object o), clear(), isEmpty(), size(), iterator(), toArray() ---- 所有单值容器(map除外)的公共接口。 
        // Interface Map: put(K key, V value), get(Object key), remove(Object key), clear(),isEmpty(),size(), keySet(), entrySet(), values()  ---- 所有K-V容器的公共接口,常见class: HashMap, Hashtable, IdentityHashMap, LinkedHashMap, ConcurrentHashMap
        // Interface Map.Entry: getKey(), getValue(), setValue(V value) ---- 用于遍历Map容器。
        //
    
        public static void main(String[] args) throws Exception {
            // ArrayList
            {
                ArrayList arraylist = new ArrayList();
                arraylist.add(0, "end");//指定索引加入值
                // 需注意的是,如果现有2个值,我加入索引为5的那么就会出现异常
                for (int i = 0; i < 2; i++) {
                    arraylist.add(i, String.valueOf(i));
                }
                System.out.println("ArrayList:");
                for (int i = 0; i < arraylist.size(); i++) {
                    System.out.print(arraylist.get(i) + ";");
                }
    
                arraylist.add("0");//直接加入值到ArrayList的最后
                arraylist.add("0");
                System.out.println("");
                System.out.print(" ArrayList's lastIndexOf(\"0\") is " + arraylist.lastIndexOf("0")); 
    
                for (Object val : arraylist) {
                    System.out.print( val + ";");
                }
                System.out.println("\n");
            }
    
            // Arrays
            {
                String[] array = new String[] { "a", "b", "c" };
                List list = Arrays.asList(array);
                System.out.println(" Arrays:");
                for (int i = 0; i < list.size(); i++) {
                    System.out.print(list.get(i) + ";");
                }
                System.out.print(" Arrays's length is " + array.length);//打印数组的长度
                
                System.out.println("");
                for (Object val : array) {
                    System.out.print( val + ";");
                }
                System.out.println("\n");
            }
    
            // Collections
            {
                String[] array = new String[] { "a", "b", "c" };
                List list = Arrays.asList(array);
                Collections.fill(list, "Fill");//用Fill填充全部元素
                System.out.println(" Collections:");
                for (int i = 0; i < list.size(); i++) {
                    System.out.print(list.get(i) + ";");
                }
                array = new String[] { "1", "2", "3" };
                List list2 = Arrays.asList(array);
                Collections.copy(list, list2);//拷贝list2的数据进list
                System.out.println(" " + list);
                Collections.swap(list, 2, 1);//调换索引为1和2的元素的位置
                System.out.println(list);
                System.out.println("\n");
            }
    
            // EventObject
            {
                String s = "hello";
                String s2 = s;
                EventObject eventobject = new EventObject(s);//一个准容器类型,确切的归类它不是容器
                System.out.println("EventObject:");
                System.out.println(eventobject.getSource());
                System.out.println(eventobject.equals(s2));
                System.out.println("\n");
            }
    
            // HashMap
            {
                HashMap hashmap = new HashMap();//一个速度最快的容器
                hashmap.put("0", "c");
                hashmap.put("1", "a");
                hashmap.put("2", "b");
                hashmap.put("3", "a");
    
                System.out.println("HashMap:");
                System.out.println(hashmap);//该容器有其内部的排序方式
                Set set = hashmap.keySet();//获取全部键
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
                    System.out.print(hashmap.get(iterator.next()) + ";");
                }
                System.out.println("");
    
                System.out.println("HashMap: K-V");
                iterator = set.iterator();
                while (iterator.hasNext()) {
                    Object key = iterator.next();
                    System.out.print(key+":"+hashmap.get(key) + ";");
                }
                System.out.println("");
    
                System.out.println("HashMap(Entry): K-V");
                Set<Map.Entry> kvSet = hashmap.entrySet();
                Iterator<Map.Entry> it = kvSet.iterator();
                while (it.hasNext()){
                    Map.Entry entry = it.next();
                    System.out.print( entry.getKey()+":" + entry.getValue() +";");
                } 
    
                System.out.println("\n");
            }
    
            // HashSet
            {
                HashSet hashset = new HashSet();//一个绝对不能重复的类型
                hashset.add("c");
                hashset.add("b");
                hashset.add("a");
                hashset.add("a");
                hashset.add("b");
                System.out.println(" HashSet:");
                System.out.println(hashset);
                Iterator iterator = hashset.iterator();//取出元素
                while (iterator.hasNext()) {
                    System.out.print(iterator.next() + ";");
                }
                System.out.println("\n");
            }
    
            // Hashtable
            {
                Hashtable hashtable = new Hashtable();//一个完全可以由其他容器替换的老容器类型
                hashtable.put("0", "c");
                hashtable.put("1", "a");
                hashtable.put("3", "c");
                hashtable.put("2", "b");
                System.out.println(" Hashtable:");
                Enumeration enumeration = hashtable.elements();//获取元素,Enumeration已经不是主流,Iterator是它的下一代替代品
                while (enumeration.hasMoreElements()) {
                    System.out.print(enumeration.nextElement() + ";");
                }
                System.out.println("\n");
            }
    
            // IdentityHashMap
            {
                IdentityHashMap identityhashmap = new IdentityHashMap();
                identityhashmap.put("0", "c");
                identityhashmap.put("1", "a");
                identityhashmap.put("3", "b");
                identityhashmap.put("2", "a");
                System.out.println(" IdentityHashMap:");
                System.out.println(identityhashmap);
                System.out.println(identityhashmap.containsKey("3"));//是否包含这个键
                System.out.println(identityhashmap.containsValue("a"));//是否包含值
                Set set = identityhashmap.entrySet();//传为Set类型
                System.out.println(set);
                set = identityhashmap.keySet();//全部键
                System.out.println(set);
                System.out.println("\n");
            }
    
            // LinkedHashMap
            {
                LinkedHashMap linkedhashmap = new LinkedHashMap();
                linkedhashmap.put("0", "b");
                linkedhashmap.put("2", "a");
                linkedhashmap.put("1", "c");
                linkedhashmap.put("3", "b");
                System.out.println("LinkedHashMap:");
                System.out.println(linkedhashmap);
                System.out.println(linkedhashmap.containsKey("2"));//是否包含这个键
                System.out.println(linkedhashmap.containsValue("c"));//是否包含值
                Set set = linkedhashmap.keySet();
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
                    System.out.print(linkedhashmap.get(iterator.next()) + ";");
                }
                System.out.println("\n");
            }
    
            // LinkedHashSet
            {
                LinkedHashSet linkedhashset = new LinkedHashSet();//它包含了几种Set的属性但却没有自己的特色
                linkedhashset.add("c");
                linkedhashset.add("a");
                linkedhashset.add("a");
                linkedhashset.add("b");
                System.out.println(" LinkedHashSet:");
                System.out.println(linkedhashset);
                System.out.println(linkedhashset.contains("a"));//是否包含对象
                Iterator iterator = linkedhashset.iterator();
                while (iterator.hasNext()) {
                    System.out.print(iterator.next() + ";");
                }
                System.out.println("\n");
            }
    
            // LinkedList
            {
                LinkedList linkedlist = new LinkedList();//自由使用是它的特色
                linkedlist.add("a");
                linkedlist.add(1, "c");
                linkedlist.addLast("b");
                linkedlist.addFirst("d");
                System.out.println(" LinkedList:");
                System.out.println(linkedlist);
                // linkedlist.clear();//该方法清空容器
                // linkedlist.remove(0);//删除索引为0的元素
                // linkedlist.remove("d");//删除值为d的元素
                // linkedlist.removeFirst();//删除第一个元素
                // linkedlist.removeLast();//删除最后一个元素
                for (int i = 0; i < linkedlist.size(); i++) {
                    System.out.print(linkedlist.get(i) + ";");
                }
                System.out.println("\n");
            }
    
            // Stack
            {
                Stack stack = new Stack();//堆栈
                stack.add("b");
                stack.add(0, "c");
                stack.push("d");
                stack.add("e");
                stack.push("a");
                Enumeration enumeration = stack.elements();
                System.out.println(" Stack:");
                while (enumeration.hasMoreElements()) {
                    System.out.print(enumeration.nextElement() + ";");
                }
                // 后进先出
                System.out.println(" " + stack.peek());
                System.out.println(stack.pop());
                System.out.println(stack.contains("d") + ";" + stack.contains("a"));//是否包含该元素,有趣的事情发生了
                System.out.println(stack.search("c"));//非常有用的属性,检索,但是由后向前的排列
                System.out.println("\n");
            }
    
            // TreeMap
            {
                TreeMap treemap = new TreeMap();
                treemap.put("0", "d");
                treemap.put("2", "a");
                treemap.put("1", "b");
                treemap.put("3", "c");
                System.out.println(" TreeMap:");//可以对键排序
                System.out.println(treemap);
                System.out.println(treemap.firstKey());//返回第一个键
                Set set = treemap.keySet();
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
                    System.out.print(treemap.get(iterator.next()) + ";");
                }
                System.out.println("\n");
            }
    
            // TreeSet
            {
                TreeSet treeset = new TreeSet();//自动排序内容
                treeset.add("b");
                treeset.add("a");
                treeset.add("c");
                treeset.add("d");
                System.out.println(" TreeSet:");
                System.out.println(treeset);
                System.out.println(treeset.first());//返回第一个元素
                Iterator iterator = treeset.iterator();
                while (iterator.hasNext()) {
                    System.out.print(iterator.next() + ";");
                }
                System.out.println("\n");
            }
    
            // Vector
            {
                Vector vector = new Vector();
                vector.add(0, "b");
                vector.add("a");
                vector.addElement("d");
                vector.add("c");
                System.out.println(" Vector:");
                System.out.println(vector);
                vector.set(2, "h");//替换掉指定索引的元素
                System.out.println(vector);
                Object[] str = vector.toArray();
                for (int i = 0; i < str.length; i++) {
                    System.out.print(str[i] + ";");
                }
                vector.setSize(2);//重新设置大小为2
                System.out.println(" " + vector);
                System.out.println("\n");
            }
    
            // WeakHashMap
            {
                WeakHashMap weakhashmap = new WeakHashMap();
                weakhashmap.put("1", "b");
                weakhashmap.put("2", "c");
                weakhashmap.put("0", "d");
                weakhashmap.put("3", "a");
                System.out.println(" WeakHashMap:");
                System.out.println(weakhashmap);
                System.out.println(weakhashmap.containsKey("3"));//是否包含键
                System.out.println(weakhashmap.containsValue("d"));//是否包含值
                Set set = weakhashmap.entrySet();
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
                    System.out.print(iterator.next() + ";");
                }
                // weakhashmap.remove("2");//删除该键对应的值
                // weakhashmap.get("1");//获取指定键的值
                System.out.println("\n");
            }
        }
    }

     

    展开全文
  • Java Map容器示例

    千次阅读 2016-08-09 23:28:36
    Map容器:键值对(Key-Value);...Java里面的Map都封装得比较好了,所以使用的话主要是要了解Java库提供了啥函数。下面看示例: package com; /** * @author lv.lang * */ import java.util.Map; import

    Map容器:键值对(Key-Value);关联数组。

    Map里面的key和value都可以是任意的对象,比如Integer,或者一个很复杂的类对象。

    Java里面的Map都封装得比较好了,所以使用的话主要是要了解Java库提供了啥函数。下面看示例:

    package com;
    
    /**
     * @author lv.lang
     *
     */
    import java.util.Map;
    import java.util.Random;
    import java.util.HashMap;
    
    public class MapTest {
    
    	public static void main(String[] args) {
    		Random rand = new Random(47);
    		Map<Integer, Integer> m = new 
    				HashMap<Integer, Integer>();
    		for(int i=0; i < 10000; i++)
    		{
    			int r = rand.nextInt(20);
    			Integer freq = m.get(r);//get方法由键获取值
    			m.put(r, freq == null ? 1 : freq + 1);//put方法存储键值对
    		}
    		System.out.println(m);
    		System.out.println(m.containsKey(16));//判断是否存在某一个key
    		System.out.println(m.containsValue(500));//判断是否存在某一个value
    	}
    
    }
    



    Map的使用不难,但是也有在某些地方谈到面试就会问用没用过Map,这就足够了,当然要求高的也会问Map背后的实现机制,之前自己面一家游戏公司就被问到了,答得不好。可能就是码农跟高级程序员的区别吧,一个只会用,一个我自己随时设计实现一个都ok。

    展开全文
  • Servlet过滤器简介 Servlet过滤器实际上就是一个标准的java类,这个通过实现Filter接口获得过滤器的功能。它在jsp容器启动的时候通过web.xml配置文件被系统加载。Servlet过滤器在接收到用户请求的时候被调用,当...
  • 前面花了好几篇的篇幅把HashMap里里外外说了个遍,大家可能对于源码分析篇已经讳莫如深了。别慌别慌,这一篇来说说集合框架里最偷懒的一个家伙——HashSet... 1.HashSet的特点和使用场景  2.HashSet的示例  3.Has...
  • 本文是主要介绍,并发容器CopyOnWriteArrayList和CopyOnWriteArraySet(不含重复元素的并发容器)的基本原理和使用示例。 欢迎探讨,如有错误敬请指正 如需转载,请注明出处 http://www.cnblogs.com/nullzx/ 1...
  • AnnotationConfigApplicationContext是Spring用来实现基于Java配置(包括各种注解)加载Spring应用上下文,以及避免使用xml配置,相比之下Java配置的这种方式更加便捷高效。 我们通过这个示例来展示下 ...
  • 这个示例在于演示通过继承java.util.Abstract来创建定制的Map和Collection,实现一个只读的Map。 //: net/mindview/util/Countries.java // "Flyweight" Maps and Lists of sample data. package ...
  • Java EE 8示例 该工作空间由Java EE 8示例和单元测试组成。 它们分类在不同的目录中,每个目录用于每个Technology / JSR。 有些样品/测试有说明文件,否则请阅读代码。 怎么跑? 使用Arquillian在Payara,...
  • Java EE 7示例 该工作空间由Java EE 7示例和单元测试组成。 它们分类在不同的目录中,每个目录用于每个Technology / JSR。 有些样品/测试有说明文件,否则请阅读代码。 手册引用了其中的大多数示例,并提供了说明。...
  • Wiremock示例使用google-http-java-client) 当我为Java制作HTTP客户端时,我知道用Wiremock制作模拟服务器将是最方便的,因此我编写了一个示例。 MyHttpClient#fetchStatus(String endpoint) 一个HTTP客户端...
  • 使用方法及示例 简介:当引入二方依赖包或三方依赖包时,可能出现外部依赖jar包与自己的工程需要依赖的冲突,或者多个二方三方依赖包互相冲突。这时候就需要一个隔离容器对他们进行隔离,其依赖的原理就是jvm认为...
  • 深入理解Java中的容器

    2021-02-24 10:21:56
    Java当中,如果有一个专门用来存放其它的对象,这个就叫做容器,或者就叫做集合,集合就是将若干性质相同或相近的对象组合在一起而形成的一个整体之所以需要容器:1、数组的长度难以扩充2、数组中数据的...
  • Spring 3 JavaConfig示例

    2020-05-26 17:22:04
    从Spring 3开始, JavaConfig功能已包含在核心Spring模块中,它使开发人员可以将bean定义和Spring配置从XML文件移到Java类中。 但是,您仍然可以使用经典的XML方式定义bean和配置, JavaConfig只是另一种替代解决...
  • 生产archetype模板 参考: mvn clean archetype:create-from-project -Dinteractive=true cd target/generated-sources/archetype/ ...(虽然iservice依赖sdk,但是要尽量避免在iservice里面使用Data和Form,只有s
  • Array都不陌生,List 是一个接口。它代表着有序的队列。...Java里把普通数组转化为List有个专门的静态方法,asList,使用示例如下:public class ArraysToList    {   public static vo...
  • 它可以在Java 7上运行,并且需要运行 *之的应用程序服务器。 使用构建的项目将生成可部署的WAR文件。 使用的注释在中定义。 *)嗯,实际上不是。 您也可以将Java Web容器嵌入到您的项目中,例如 ,并完成此操作...
  • 一、Optional 是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。 二、Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,...
  • Java SE 是什么,包括哪些内容(二十一)?...你必须使用类Arrays的方法toString()来产生数组的可打印表示 容器的打印无需任何的帮助,不需要特别使用哪个方法。 代码示例: // 容器的打印 //PrintingContainers ...
  • 集合概述:集合是java中提供的一种容器,可以用来存储多个数据 集合与数组都是容器,他们两个的区别是什么? 区别: 数组的长度是固定的,集合的长度是可变的. 数组中存储的是同一类型的元素,可以存储基本数据类型值.集合...
  • httpUnit介绍及使用示例

    千次阅读 2018-04-05 11:50:50
    内容摘要HttpUnit是一个集成测试工具,主要关注Web应用的测试,提供的帮助让测试者可以通过Java类和服务器进行交互,并且将服务器端的响应当作文本或者DOM对象进行处理。HttpUnit还提供了一个模拟Servlet容器,让...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 325
精华内容 130
关键字:

java容器类使用示例

java 订阅