com.intellij.util.ReflectionUtil 对方法 java.util.ResourceBundle.setParent(java.util.ResourceBundle) 的非法反射访问

如何解决com.intellij.util.ReflectionUtil 对方法 java.util.ResourceBundle.setParent(java.util.ResourceBundle) 的非法反射访问

我在 VSCode 中编写了一些 kotlin 代码

其中之一是：

public void readCSV(String fileName) {
    fileLocation = fileName;
    File csvFile = new File(fileName);
    Scanner sfile;
//    noOfColumns = 0;
//    noOfRows = 0;
    data = new ArrayList<ArrayList>();
    int colCounter = 0;
    int rowCounter = 0;
    
    try {
        sfile = new Scanner(csvFile);
        
        while (sfile.hasNextLine()) {
            String aLine = sfile.nextLine();
            Scanner sline = new Scanner(aLine);
            sline.useDelimiter(",");
            colCounter = 0;
            while (sline.hasNext()) {
                if (rowCounter == 0) 
                    data.add(new ArrayList<String>());
                
                
                data.get(colCounter).add(sline.next());
                colCounter++;
            }
            rowCounter++;
            sline.close();
        }
//        noOfColumns = colCounter;
//        noOfRows = rowCounter;
        sfile.close();
    } catch (FileNotFoundException e) {
        System.out.println("File to read " + csvFile + " not found!");
    }
} 

当我运行它时，我得到：

fun main() {
println("Hello world")
}

它有效，但我无法隐藏或修复警告，我使用 JDK 15

我在 IntelliJ 上没有收到这些警告

guava:java:java.util.Map 和 java.util.Set 的 Key 类型转换

昨天写了一博客《java:java.util.Map 和 java.util.Set 的 Key 类型转换》, 主要是想实现以 java.util.MapKey 类型转换，今天有空有研究了一下 guava 的代码，发现基于 guava 提供的 API 也是可以实现 Key 类型转换的： 关键就是 Maps 提供了 uniqueIndex 方法，可以将 Map 转换成 Key 不同的 Map。

package net.gdface.facelog;

import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

import com.google.common.base.Function;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterators;
import com.google.common.collect.Maps;
import com.google.common.collect.Maps.EntryTransformer;

public class TestTransform {
    /** 
     * convert {@code Map<K1,V>} to {@code Map<K2,V>}   
     * @return {@linkplain ImmutableMap}
     */
    public static final <K1,K2,V>Map<K2,V> transform(Map<K1,V>fromMap,final Function<K1,K2>transformer){
        checkNotNull(fromMap,"fromMap is null");
        checkNotNull(transformer,"transformer is null");
        // 新的Map对象Key类型已经是K2了，只是Value类型成了Entry
        ImmutableMap<K2, Entry<K1, V>> k2Entry = Maps.uniqueIndex(fromMap.entrySet(), new Function<Entry<K1, V>,K2>(){
            @Override
            public K2 apply(Entry<K1, V> input) {               
                return transformer.apply(input.getKey());
            }});
        // 再做一次转换将Entry<K1, V>转换成V,这个过程并没有创建新的Map,只是创建了k2Entry的代理对象
        Map<K2, V> k2V = Maps.transformEntries(k2Entry, new EntryTransformer<K2,Entry<K1,V>,V>(){
            @Override
            public V transformEntry(K2 key, Entry<K1, V> value) {
                return value.getValue();
            }});
        return k2V;
    }
    /** 
     * convert {@code Set<E1>} to {@code Set<E2>}
     * @return {@link ImmutableSet} 
     */
    public static final <E1,E2>Set<E2> transform(final Set<E1>fromSet,final Function<E1,E2>transformer){
        checkNotNull(fromSet,"fromMap is null");
        checkNotNull(transformer,"transformer is null");
        return ImmutableSet.copyOf(Iterators.transform(fromSet.iterator(), transformer));
    }
    @Test
    public void test() {
        Map<String, String> m1 = Maps.<String,String>newLinkedHashMap();
        m1.put("1", "apple");
        m1.put("2", "orangle");
        m1.put("3", "banana");
        System.out.println(m1);
        Map<Integer, String> m2 = transform(m1, new Function<String,Integer>(){

            @Override
            public Integer apply(String input) {
                return Integer.valueOf(input);
            }});
        System.out.println(m2.toString());
    }

}

注意： 这个方法相比上篇博客中的方法要简单的多但是有区别的： 返回的 Map 对象是一个新的对象，与原 Map 对象没有任何关联，并且是不可变的 (immutable)。 而上一篇博客中的方法返回的 Map 对象则是原对象的代理对象，并且是可变的 (mutable)，对新对象的任何操作实际都是对原对象的操作。

Java List，List <？>，List ，List 和List