如何在不返回集合本身的前提下让其他类安全访问集合数据？

当然可以！你的需求很清晰——就是让B类能遍历集合里的数据，但完全不能修改集合，也不能调用add()、isEmpty()这类额外方法。下面针对ArrayList和HashMap两种类型分别给你具体的实现方案：

1. 处理ArrayList（List 私有字段） #

核心思路是返回一个仅实现Iterable<T>接口的对象，而不是直接返回List本身。Iterable接口只有一个iterator()方法，刚好支持foreach遍历，却完全屏蔽了List的所有其他方法。同时我们还要包装迭代器，禁用remove()方法，防止通过迭代器间接修改集合。

A类实现示例： #

import java.util.ArrayList;
import java.util.Iterator;

public class A {
    private ArrayList<String> listData = new ArrayList<>();

    // 初始化测试数据
    public A() {
        listData.add("Apple");
        listData.add("Banana");
        listData.add("Cherry");
    }

    // 返回仅支持遍历的Iterable，不暴露List的任何额外方法
    public Iterable<String> getListData() {
        return new Iterable<String>() {
            @Override
            public Iterator<String> iterator() {
                // 包装原集合的迭代器，禁用remove操作
                return new Iterator<String>() {
                    private final Iterator<String> originalIterator = listData.iterator();

                    @Override
                    public boolean hasNext() {
                        return originalIterator.hasNext();
                    }

                    @Override
                    public String next() {
                        return originalIterator.next();
                    }

                    @Override
                    public void remove() {
                        throw new UnsupportedOperationException("无法修改该集合");
                    }
                };
            }
        };
    }
}

B类使用方式： #

public class B {
    public void processListData(A a) {
        // 仅能通过foreach遍历，没有add()、isEmpty()等方法
        for (String item : a.getListData()) {
            System.out.println(item);
        }

        // 以下代码都会编译报错，因为Iterable没有这些方法
        // a.getListData().add("Date");
        // a.getListData().isEmpty();
    }
}

2. 处理HashMap（Map<K, V> 私有字段） #

HashMap的遍历通常针对键值对（Entry）、键（Key）或值（Value），我们可以根据需求返回对应类型的Iterable，同样包装迭代器和Entry对象，彻底禁用修改操作。

A类实现示例（返回键值对Iterable）： #

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class A {
    private HashMap<Integer, String> mapData = new HashMap<>();

    // 初始化测试数据
    public A() {
        mapData.put(1, "One");
        mapData.put(2, "Two");
        mapData.put(3, "Three");
    }

    // 返回仅支持遍历的键值对Iterable，屏蔽Map的所有额外方法
    public Iterable<Map.Entry<Integer, String>> getMapEntries() {
        return new Iterable<Map.Entry<Integer, String>>() {
            @Override
            public Iterator<Map.Entry<Integer, String>> iterator() {
                return new Iterator<Map.Entry<Integer, String>>() {
                    private final Iterator<Map.Entry<Integer, String>> originalIterator = mapData.entrySet().iterator();

                    @Override
                    public boolean hasNext() {
                        return originalIterator.hasNext();
                    }

                    @Override
                    public Map.Entry<Integer, String> next() {
                        // 返回不可修改的Entry对象，防止修改键值对
                        Map.Entry<Integer, String> originalEntry = originalIterator.next();
                        return new Map.Entry<Integer, String>() {
                            @Override
                            public Integer getKey() {
                                return originalEntry.getKey();
                            }

                            @Override
                            public String getValue() {
                                return originalEntry.getValue();
                            }

                            @Override
                            public String setValue(String value) {
                                throw new UnsupportedOperationException("无法修改该键值对");
                            }
                        };
                    }

                    @Override
                    public void remove() {
                        throw new UnsupportedOperationException("无法修改该集合");
                    }
                };
            }
        };
    }
}

B类使用方式： #

public class B {
    public void processMapData(A a) {
        for (Map.Entry<Integer, String> entry : a.getMapEntries()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // 以下代码要么编译报错，要么运行时报错
        // 编译报错：Iterable没有put()、containsKey()等方法
        // a.getMapEntries().put(4, "Four");
        // a.getMapEntries().containsKey(1);

        // 运行时报错：无法修改Entry的value
        // entry.setValue("Modified");
    }
}

Java 8+ 简化写法 #

如果你的项目用的是Java 8及以上，可以用Lambda表达式简化Iterable的创建，让代码更简洁：

简化后的List处理： #

public Iterable<String> getListData() {
    return () -> new Iterator<String>() {
        private final Iterator<String> original = listData.iterator();

        @Override
        public boolean hasNext() {
            return original.hasNext();
        }

        @Override
        public String next() {
            return original.next();
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("无法修改该集合");
        }
    };
}

为什么不用Collections.unmodifiableList？ #

你可能会想到用Collections.unmodifiableList()，但它返回的还是List接口的实例——虽然不能修改集合，但B类仍然可以调用isEmpty()、size()等List的方法，这不符合你“仅允许访问数据，无法调用add()、isEmpty()等方法”的严格需求。而返回Iterable则完全屏蔽了这些额外方法，完美契合你的要求。

内容的提问来源于stack exchange，提问作者John