首页 > 编程语言 >Java小白一文讲清Java中集合相关的知识点(八)

Java小白一文讲清Java中集合相关的知识点(八)

时间:2024-09-11 14:51:27浏览次数:11  
标签:知识点 Java String list System 讲清 key println out

HashMap底层机制及源码剖析

在这里插入图片描述

  • HashMap底层维护了Node类型的数组table,默认为null

  • 当创建对象时,将加载因子初始化为0.75;

  • 当添加key-value时,通过key的哈希值得到在table的索引,然后判断该索引处是否有元素,如果没有元素直接添加,如果该索引处有

    元素,继续判断该元素的key是否和准备加入的key相等,如果相等,则直接替换val;如果不相等需要判断是树结构还是链表结构,做出相应处理,如果添加时发现容量不够,则需要扩容 resize();

  • 第一次添加,则需要扩容table容量为16,临界值threshold为12

  • 以后再扩容,则需要扩容table容量为原来的2倍,临界值为原来的2倍,即24,依次类推;

  • 在Java8中,如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8),并且table的大小>= MIN_TREEIFY_CAPACITY(默认是64),就会进行树化(红黑树);

HashMap源码解读

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //如果table的索引位置的key的hash和新的key的hash值相同,并
            //满足(table 现有的结点的key和准备添加的key是同一个对象  || equals返回真,就认为不能加入新的k-v)
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //如果当前的table的已有的Node是红黑树,就按照红黑树的方式来处理
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //如果找到的结点,后面是链表,就循环比较
                for (int binCount = 0; ; ++binCount) {//死循环
                    if ((e = p.next) == null) {//走到最后了,还没找到与之相同的 
                        //加到链表的屁股后面
                        p.next = newNode(hash, key, value, null);
                        //判断是不是链表中加满了八个
                        if (binCount >= TREEIFY_THRESHOLD - 1) //>= (8-1=7)
                            //树化,当然这里不是立即树化哈,深挖进去,会发现还要满足table的长度>=64
                            //才会树化,反之不符合条件就选择扩容,不急着树化
                            treeifyBin(tab, hash);
                        //我找了一圈,发现没有找到和我一样的,就把我加到屁股后面,然后退出
                        break;
                    }
                    //循环比较的过程中,我发现有一个是相同的,即hash值也相同||值相同,我就退出
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;//替换找到的重复key对应的value
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;//每成功增加一个,就++
        if (++size > threshold)//12--24--48,一旦发现到了threshold临界值,就进入分支开始扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }




//树化部分的源码
    final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        //如果table暂时为null,或者大小还没有到 64,暂时不树化,而是进行扩容
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if (
            .......
        }
    }

HashTable

  • 存放的元素是键值对: 即 k-v
  • hashtable的键和值都不能为null,否则会抛出空指针异常
  • hashTable使用方法基本上和HashMap一样
  • hashTable是线程安全的(因为有synchronized修饰),hashMap是线程不安全的
  • 底层源码剖析
//简单说明一下HashTable的底层
/**
1.底层有数组Hashtable$Entry[]  初始化大小为11
2.临界值 threshold 为 8--> 11*0.75;
3.扩容:按照自己的扩容机制来进行
4.By  执行 addEntry(hash, key, value, index);
	添加K-V ,将其封装到Entry中去
5.当if (count >= threshold) 满足时,就进行扩容
6.按照int newCapacity = (oldCapacity << 1) + 1; 的大小扩容
*/

public synchronized V put(K key, V value) {
    if (value == null) {
            throw new NullPointerException();
        }
    // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
//hashtable的底层是entry数组,通过以下的add方法将key、value放进entry中,然后添加到数组中去
        addEntry(hash, key, value, index);
        return null;
    }

}


//addEntry方法底层
    private void addEntry(int hash, K key, V value, int index) {
        modCount++;

        Entry<?,?> tab[] = table;
        //当存放的元素数量大于临界值
        if (count >= threshold) {
           //进入这个方法
            rehash();

            tab = table;
            hash = key.hashCode();
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>) tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
    }


//rehash()底层源码
    @SuppressWarnings("unchecked")
    protected void rehash() {
        //oldCapacity起初为11嘛
        int oldCapacity = table.length;
        Entry<?,?>[] oldMap = table;

        // 扩容后新的容量=oldCapacity乘以2,再+1;
        //这就是起初容量为11,之后扩容后变为11*2+1=23的原因
        int newCapacity = (oldCapacity << 1) + 1;
        //如果新容量-数组最大值2147483639仍然大于0,则进入分支
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            
            if (oldCapacity == MAX_ARRAY_SIZE)
                // Keep running with MAX_ARRAY_SIZE buckets
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }
        Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

        modCount++;
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        table = newMap;

        for (int i = oldCapacity ; i-- > 0 ;) {
            for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
                Entry<K,V> e = old;
                old = old.next;

                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = (Entry<K,V>)newMap[index];
                newMap[index] = e;
            }
        }
    }

HashMap和HashTable之间的对比

线程安全(同步)效率允许null键 null值
HashMap不安全可以
HashTable安全较低不可以

Properities

  • Properities类继承自HashTable类并且实现了Map接口,也是使用了一种键值对的形式来保存数据
  • 它的使用特点和HashTable类似
  • Properities还可以用于从xxx.properities文件中,加载数据到Properties类对象,并进行读取和修改
  • 说明:工作后,xxxx.properities文件通常作为配置文件,这个知识点在IO流举例;

TreeSet

  • 自动排序,TreeSet中的元素会自动按照自然顺序,例如数字从小到大,字母按照字典顺序,或者通过自定义的比较器排列;
  • 不允许重复元素,TreeSet会检查插入的元素是否已经存在,如果存在相同的元素,新的元素将不会被添加
      public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        //1.当我们使用无参构造器,创建TreeSet时,仍然是无序的
        treeSet.add("jason");
        treeSet.add("R");
        treeSet.add("K");
        treeSet.add("AAA");

        System.out.println(treeSet);
        //[AAA, K, R, jason]

        //2.我希望添加的元素,可以按照字符串大小来排序
        //3.我们可以使用TreeSet提供的一个构造器,可以传入一个比较器(匿名内部类)
        //  并指定排序规则
        TreeSet treeSetNB = new TreeSet(new Comparator() {

//源码解读,当传给TreeSet一个比较器时,深挖底层,我们会发现其将传入的比较器对象 赋给了TreeSet底层的
//TreeMap的属性this.comparator,也就是将匿名对象,传给了底层TreeMap的comparator属性
            /**
	public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }*/
//在调用treeSet.add("AAA")时,在底层会执行到
            /**
            //此中的cpr就是我们的匿名内部类(对象)
            	Comparator<? super K> cpr = comparator;
                    if (cpr != null) {
                        do {
                            parent = t;
                            //动态绑定到我们的匿名内部类(对象) compare
                            cmp = cpr.compare(key, t.key);
                            if (cmp < 0)
                                t = t.left;
                            else if (cmp > 0)
                                t = t.right;
                                //如果相等,即返回0,那么这个key就没有加入
                            else
                                return t.setValue(value);
                        } while (t != null);
       		    }
            */
            @Override
            public int compare(Object o1, Object o2) {
                //这里的这句话调用字符串的compareTo方法,默认按照字符串来比较大小
                //这里实现从大到小的比较规则
                return ((String)o2).compareTo((String)o1);
            }
        });
        treeSetNB.add("jason");
        treeSetNB.add("K");
        treeSetNB.add("R");
        treeSetNB.add("AAA");

        System.out.println("添加了比较器后的treeSet:"+treeSetNB);



    }



TreeMap

  • 键的排序:TreeMap按照键的自然顺序,例如数字从小到大,字母按字典顺序,或者根据提供的Comparator 进行排序;

    ​ 因此,插入元素时会自动排序,而不是按照插入的顺序存储;

  • 不允许null键:TreeMap不允许null作为键,这与HashMap允许一个nulll键不同,但是TreeMap允许null值,可以有多个null值;

    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap();
        treeMap.put("1",null);
        treeMap.put("2",null);
        System.out.println(treeMap);
        //{1=null, 2=null}
    }

Collection工具类

  • Collection是一个操作Set、List和Map等集合的工具类
  • Collection中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作
  • 排序操作
  • reverse(List):反转List中元素的顺序
  • shuffle(List):对List集合元素进行随机排序
  • sort(List):根据元素的自然顺序对指定List集合元素按升序排序
  • sort(List,Comparator):根据指定的Comparator 产生的顺序对List 集合元素进行排序
  • swap(List,int,int):将指定List集合中的 i 处元素和 j 处元素进行交换
    public static void main(String[] args) {
        //创建ArrayList 集合,用于测试。
        ArrayList list = new ArrayList();
        list.add("kerwin");
        list.add("h活在当下hhh");
        list.add("AA感受每一段旅程");
        list.add("moment");

        System.out.println(list);
        //[kerwin, h活在当下hhh, AA感受每一段旅程, moment]

        //reverse 反转
        Collections.reverse(list);
        System.out.println(list);
        //[moment, AA感受每一段旅程, h活在当下hhh, kerwin]

        //shuffle  随机排序
        Collections.shuffle(list);
        System.out.println(list);
        //[h活在当下hhh, AA感受每一段旅程, kerwin, moment]

        //sort  根据元素的自然顺序对指定的List集合元素按升序排序
        Collections.sort(list);
        System.out.println(list);
        //[AA感受每一段旅程, h活在当下hhh, kerwin, moment]

        //sort(list , Comparator) 传入比较器进行排序
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                String str1 = (String)o1;
                String str2 = (String)o2;
                return str2.compareToIgnoreCase(str1);
            }
        });
        System.out.println(list);
        //[moment, kerwin, h活在当下hhh, AA感受每一段旅程]

        //swap  将指定List集合中的i 处元素和 j 处元素进行交换;
        Collections.swap(list,0,1);b `	1N2QWA
        System.out.println(list);
        //[kerwin, moment, h活在当下hhh, AA感受每一段旅程]
    }

  • 查找、替换
  • Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
  • Object max(Collection ,Comparator):根据Comparator指定的顺序返回给定集合中的最大元素
  • Object min(Collection)
  • Object max(Collection,Comparator)
  • int frequency(Collection ,Object):返回指定集合中指定元素的出现次数
  • void copy(List dest, List src):将src 中的内容复制到dest中
  • boolean replaceAll(List list ,Object oldVal,Object newVal):使用新值替换List对象的所有旧值
    public static void main(String[] args) {
        //创建ArrayList 集合,用于测试。
        ArrayList list = new ArrayList();
        list.add("kerwin");
        list.add("hhhh");
        list.add("AAjourney");
        list.add("moment");

        System.out.println(list);
        //[kerwin, hhhh, AAjourney, moment]


        //Object max(Collection);  返回给定集合中的最大元素
        System.out.println("自然顺序下的最大元素");
        System.out.println(Collections.max(list));
        //moment

        //自定义比较器,然后返回自定义规则下的最大元素
        //比如,我要返回长度最大的元素
        Object maxObject = Collections.max(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                String str1 = (String)o1;
                String str2 = (String)o2;

                return str1.length()-str2.length();
                /**
                 * return ((String)o1).length()-((String)o2).length();
                 */
            }
        });
        System.out.println("自定义比较器下的最长元素");
        System.out.println(maxObject);
        //AAjourney

        //min(Collection)
        System.out.println("自然顺序下的最小元素:");
        System.out.println(Collections.min(list));
        //AAjourney


        //同样,实现自定义比较器,然后返回长度最小的元素
        Object minObject = Collections.min(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                /**
                 * 这里想补充一点容易犯错的点:你要像下面这样写的时候,务必要留意括号的位置,
                 * ((String)o1)  这个对应的才是String,才会有length()API可以调用
                 * 如果不留意这一点,就会频频报错hhh
                 *
                 */
                return ((String) o1).length() - ((String) o2).length();
            }
        });
        System.out.println("自定义比较器下的最短元素");
        System.out.println(minObject);
        //hhhh

        //  int  frequency(Collection Object) 返回指定集合中指定元素出现的次数
        list.add("hhhh");
        System.out.println(list);
        //[kerwin, hhhh, AAjourney, moment, hhhh]

        int hhhhFre = Collections.frequency(list, "hhhh");
        System.out.println(hhhhFre);
        //2  即"hhhh"这个对象在集合中出现了2次

        //void copy(List dest,List src)
        ArrayList testList = new ArrayList();
        testList.add("Bingo");
        testList.add("Bingo");
        //将testList集合中的元素,复制到list中去
        Collections.copy(list,testList);
        System.out.println(testList);
        //[Bingo, Bingo]

        System.out.println(list);
        //[Bingo, Bingo, AAjourney, moment, hhhh]


        //boolean replaceAll(List list, Object oldVal, Object newVal)
        Collections.replaceAll(list,"hhhh","hhhhhDamn");
        System.out.println(list);
        //[Bingo, Bingo, AAjourney, moment, hhhhhDamn]


    }
	

拓展:比较器专题练习

      public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");
        list.add("kiwi");

        //1.按照字符串的长度来 进行从短到长排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        System.out.println("按照字符串长度,由短到长排序如下:");
        System.out.println(list);
        //[kiwi, apple, banana, cherry]

        //2.按照字符串的最后一个字符从大到小排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                /**
                 * 这样也行!!!
                 *  char lastChar1 = o1.charAt(o1.length() - 1);
                    char lastChar2 = o2.charAt(o2.length() - 1);
                    return Character.compare(lastChar2, lastChar1);  // 从大到小排序
                 */
                return o2.charAt(o2.length()-1)-o1.charAt(o1.length()-1);
            }
        });
        System.out.println("按照字符串的最后一个字符从大到小排序:");
        for(String obj : list){
            System.out.print(obj+"\t");
        }
        //cherry	kiwi	apple	banana

        //3.按字符串中的元音字母数量从多到少排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return countVowels(o2) - countVowels(o1);  // 从多到少排序
            }
            private int countVowels(String str) {
                int count = 0;
                for (char c : str.toLowerCase().toCharArray()) {
                    if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
                        count++;
                    }
                }
                return count;
            }
        });
        System.out.println();
        System.out.println("按字符串中的元音字母数量从多到少排序,如下:");
        System.out.println(list);
        //[banana, kiwi, apple, cherry]

        //4.按字符串字母逆序排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.toCharArray()[0]-o1.toCharArray()[0];
            }
        });
        System.out.println("按字符串字母逆序排序");
        System.out.println(list);
        //[kiwi, cherry, banana, apple]

        //5.按字符串是否以元音字母开头排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                boolean startsWithVowel1 = startsWithVowel(o1);
                boolean startsWithVowel2 = startsWithVowel(o2);

                if (startsWithVowel1 && !startsWithVowel2) {
                    return -1;
                } else if (!startsWithVowel1 && startsWithVowel2) {
                    return 1;
                } else {
                    return o1.compareTo(o2);  // 如果开头情况相同,则按字母顺序排序
                }
            }

            private boolean startsWithVowel(String str) {
                char firstChar = Character.toLowerCase(str.charAt(0));
                return firstChar == 'a' || firstChar == 'e' || firstChar == 'i' || firstChar == 'o' || firstChar == 'u';
            }
        });
        System.out.println("按字符串是否以元音字母开头排序");
        System.out.println(list);
        //[apple, banana, cherry, kiwi]

    }

//输出结果如下:
按照字符串长度,由短到长排序如下:
[kiwi, apple, banana, cherry]
按照字符串的最后一个字符从大到小排序:
cherry	kiwi	apple	banana	
按字符串中的元音字母数量从多到少排序,如下:
[banana, kiwi, apple, cherry]
按字符串字母逆序排序
[kiwi, cherry, banana, apple]
按字符串是否以元音字母开头排序
[apple, banana, cherry, kiwi]

集合总结

开发中如何选择集合实现类

  • 先判断存储的类型(一组对象或一组键值对)
  • 一组对象(单列数据):Collection接口
    • 允许重复:List
      • 增删多:LinkedList[底层维护了一个双向链表]
      • 改查多:ArrayList[底层维护了Object 类型的可变数组]
    • 不允许重复:Set
      • 无序:HashSet [底层是HashMap,维护了一个哈希表,即数组+链表+红黑树]
      • 排序:TreeSet
      • 插入和取出顺序一致:LinkedHashSet 维护数组+ 双向链表
  • 一组键值对(双列):Map
    • 键无序:HashMap [ 底层是:哈希表 jdk7:数组+链表 jdk8:数组+链表+红黑树 ]
    • 键排序:TreeMap
    • 键插入和取出顺序一致:LinkedHashMap
    • 读取文件:Properties

标签:知识点,Java,String,list,System,讲清,key,println,out
From: https://blog.csdn.net/Kerwin_D/article/details/142067992

相关文章

  • Java中的线程优先级与调度:如何有效管理线程的执行顺序
    Java中的线程优先级与调度:如何有效管理线程的执行顺序大家好,我是微赚淘客返利系统3.0的小编,是个冬天不穿秋裤,天冷也要风度的程序猿!在Java中,线程的优先级和调度策略对于高效管理线程执行顺序至关重要。通过合理地设置线程优先级和调度策略,可以有效地优化应用的性能和响应时间。本......
  • 如何在Java服务中使用Circuit Breaker模式:Hystrix与Resilience4j的比较
    如何在Java服务中使用CircuitBreaker模式:Hystrix与Resilience4j的比较大家好,我是微赚淘客返利系统3.0的小编,是个冬天不穿秋裤,天冷也要风度的程序猿!在分布式系统中,服务调用的稳定性和可靠性至关重要。CircuitBreaker(熔断器)模式可以有效地防止服务故障的蔓延,保护系统的稳定性。本......
  • Java服务端中的数据验证:使用Bean Validation与Spring Validator的最佳实践
    Java服务端中的数据验证:使用BeanValidation与SpringValidator的最佳实践大家好,我是微赚淘客返利系统3.0的小编,是个冬天不穿秋裤,天冷也要风度的程序猿!在Java服务端开发中,数据验证是确保应用数据准确性和可靠性的关键步骤。本文将探讨BeanValidation和SpringValidator这两种数......
  • Java的class与String互相转换,自定义密码策略
    目的客户要求密码校验方式,用自己的认证方式。提供一种方案,在不出补丁的情况下,解决这个问题。原理1、本地写一个类,用客户想要的方案,实现密码校验的接口,编译成class类。2、然后把这个class类,先转换成二进制,再转换成16进制的字符串。3、将字符串写到客户的数据库里。4、重启服务,在......
  • Java中的缓存穿透与雪崩问题:解决方案与设计模式
    Java中的缓存穿透与雪崩问题:解决方案与设计模式大家好,我是微赚淘客返利系统3.0的小编,是个冬天不穿秋裤,天冷也要风度的程序猿!在分布式系统中,缓存是提高性能的重要手段。然而,缓存系统在实际应用中常常会遇到缓存穿透和缓存雪崩这两种问题。本文将探讨这两种问题的成因以及在Java中......
  • Java中的负载测试:从单元测试到集成测试的完整覆盖策略
    Java中的负载测试:从单元测试到集成测试的完整覆盖策略大家好,我是微赚淘客返利系统3.0的小编,是个冬天不穿秋裤,天冷也要风度的程序猿!今天我们来聊一聊Java中的负载测试。负载测试是保证系统性能和稳定性的重要手段,而完整的测试策略不仅包括单元测试,还要覆盖到集成测试。本文将从单......
  • 如何在Java中实现应用的动态扩展:基于热插拔与插件机制的实现
    如何在Java中实现应用的动态扩展:基于热插拔与插件机制的实现大家好,我是微赚淘客返利系统3.0的小编,是个冬天不穿秋裤,天冷也要风度的程序猿!在现代应用开发中,为了应对不断变化的需求和快速迭代的要求,应用的动态扩展能力变得尤为重要。实现动态扩展的关键技术包括热插拔和插件机制。......
  • Java服务端开发中的请求优化:从HTTP/1.1到HTTP/2与gRPC的升级
    Java服务端开发中的请求优化:从HTTP/1.1到HTTP/2与gRPC的升级大家好,我是微赚淘客返利系统3.0的小编,是个冬天不穿秋裤,天冷也要风度的程序猿!在现代Java服务端开发中,提升请求性能是至关重要的。随着HTTP/2和gRPC的引入,优化请求性能变得更加有针对性和高效。本文将探讨如何从HTTP/1.1......
  • Java中的元编程:使用反射与代理模式实现代码的动态增强
    Java中的元编程:使用反射与代理模式实现代码的动态增强大家好,我是微赚淘客返利系统3.0的小编,是个冬天不穿秋裤,天冷也要风度的程序猿!在Java开发中,元编程是指在程序运行时对程序进行修改和扩展的技术。反射和代理模式是实现Java元编程的两种常用技术。本文将探讨如何使用反射与代理......
  • Java中的安全编码实践:如何防止SQL注入与XSS攻击
    Java中的安全编码实践:如何防止SQL注入与XSS攻击大家好,我是微赚淘客返利系统3.0的小编,是个冬天不穿秋裤,天冷也要风度的程序猿!在Java开发中,安全编码是确保应用程序免受攻击的关键因素。SQL注入和跨站脚本攻击(XSS)是最常见的安全漏洞之一。本文将介绍如何在Java中防止这两种攻击,并提......