复制代码List<String> students = new ArrayList<>();
students.add("Tom");
students.add("Jerry");
students.add("Alice");

for (int i = 0; i < students.size(); i++) {
    System.out.println(students.get(i));
}

复制代码import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

interface PreorderIterator<T> extends Iterator<T> {
    boolean hasNext();

    T next();
}

interface PreorderCollection<T> extends Iterable<T> {
    PreorderIterator<T> iterator();
}

class Student {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

class StudentCollection implements PreorderCollection<Student> {
    private List<Student> students;

    public StudentCollection() {
        students = new ArrayList<>();
    }

    public void addStudent(Student student) {
        students.add(student);
    }

    @Override
    public PreorderIterator<Student> iterator() {
        return new PreorderStudentIterator(students);
    }
}

class PreorderStudentIterator implements PreorderIterator<Student> {
    private List<Student> students;
    private int position;

    public PreorderStudentIterator(List<Student> students) {
        this.students = students;
        position = 0;
    }

    @Override
    public boolean hasNext() {
        return position < students.size();
    }

    @Override
    public Student next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }

        Student student = students.get(position++);
        return student;
    }
}

public class Main {
    public static void main(String[] args) {
        StudentCollection studentCollection = new StudentCollection();
        studentCollection.addStudent(new Student("Tom"));
        studentCollection.addStudent(new Student("Jerry"));
        studentCollection.addStudent(new Student("Alice"));

        PreorderIterator<Student> iterator = studentCollection.iterator();

        while (iterator.hasNext()) {
            Student student = iterator.next();
            System.out.println(student.getName());
        }
    }
}

复制代码class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}

class BinaryTree implements PreorderCollection<Integer> {
    private TreeNode root;

    public BinaryTree(TreeNode root) {
        this.root = root;
    }

    @Override
    public PreorderIterator<Integer> iterator() {
        return new PreorderTreeIterator(root);
    }
}

class PreorderTreeIterator implements PreorderIterator<Integer> {
    private Stack<TreeNode> stack;

    public PreorderTreeIterator(TreeNode root) {
        stack = new Stack<>();
        if (root != null) {
            stack.push(root);
        }
    }

    @Override
    public boolean hasNext() {
        return !stack.isEmpty();
    }

    @Override
    public Integer next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }

        TreeNode node = stack.pop();
        if (node.right != null) {
            stack.push(node.right);
        }
        if (node.left != null) {
            stack.push(node.left);
        }
        return node.val;
    }
}

public class Main {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(7);

        BinaryTree binaryTree = new BinaryTree(root);

        for (int val : binaryTree) {
            System.out.print(val + " ");
        }
    }
}

CreateSchoolRequest request = CreateSchoolRequest.builder().name("test").build();
CreateSchoolServiceRequest createSchoolServiceRequest = Converter.directConvert(request, CreateSchoolServiceRequest.class);

CreateSchoolRequest input = CreateSchoolRequest.builder()
        .name("test1")
        .address("test address1")
        .build();
CreateSchoolRequest input1 = CreateSchoolRequest.builder()
        .name("test2")
        .address("test address2")
        .build();
List<CreateSchoolRequest> createSchoolRequests = Arrays.asList(input, input1);
List<CreateSchoolServiceRequest> createSchoolServiceRequests = Converter.directConvertCollectionSingle(createSchoolRequests, CreateSchoolServiceRequest.class);

@Slf4j
@Component
public class RequestToResponseConverter implements Converter<Request, Response> {

    @Override
    public Response convert(Request source) {
        if (source == null) {
            return null;
        }
        log.info("RequestToResponseConverter.convert: {}", source);
        Response target = new Response();
        target.setName(source.getName());
        return target;
    }
}

public static void fromJavaFile() {
    // 获取Javac编译器对象
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    // 获取文件管理器：负责管理类文件的输入输出
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
    // 获取要被编译的Java源文件
    File file = new File("/Users/oneyoung/oneyoung/project/my/code/src/main/java/top/oneyoung/dynamic/TestHello.java");
    // 通过源文件获取到要编译的Java类源码迭代器，包括所有内部类，其中每个类都是一个JavaFileObject
    Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjects(file);
    // 生成编译任务
    JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, null, null, compilationUnits);
    // 执行编译任务
    task.call();
}

public class TestHello {
    public static void main(String[] args) {
        System.out.println("this is a test");
    }
}

public static Class<?> loadClassFromDisk(String path) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    // defineClass 为 ClassLoader 类的一个方法，用于加载类
    // 但是这个方法是 protected 的，所以需要通过反射的方式获取这个方法的权限
    Class<ClassLoader> classLoaderClass = ClassLoader.class;
    Method defineClass = classLoaderClass.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
    defineClass.setAccessible(true);
    // 读取文件系统的 file 为 byte 数组
    File file = new File(path);
    byte[] bytes = new byte[(int) file.length()];
    try (FileInputStream fileInputStream = new FileInputStream(file)) {
        fileInputStream.read(bytes);
    } catch (IOException e) {
        e.printStackTrace();
    }
    // 执行 defineClass 方法 返回 Class 对象
    return (Class<?>) defineClass.invoke(Thread.currentThread().getContextClassLoader(), bytes, 0, bytes.length);
}

// 执行编译任务
Boolean call = task.call();
if (call) {
    Class<?> o = loadClassFromDisk("/Users/oneyoung/oneyoung/project/my/code/src/main/java/top/oneyoung/dynamic/TestHello.class");
    Method main = o.getMethod("main", String[].class);
    main.invoke(null, new Object[]{new String[]{}});
}

public class SourceJavaFileObject extends SimpleJavaFileObject {

    /**
     * The source code of this "file".
     */
    private final String code;

    SourceJavaFileObject(String name, String code) {
        super(URI.create("string:///" + name.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE);
        this.code = code;
    }

    @Override
    public CharSequence getCharContent(boolean ignoreEncodingErrors) {
        return code;
    }
}

// 通过源代码字符串获取到要编译的Java类源码迭代器，包括所有内部类，其中每个类都是一个JavaFileObject
SourceJavaFileObject javaFileObject = new SourceJavaFileObject("TestHello", "public class TestHello { public static void main(String[] args) { System.out.println(\"Hello World\"); } }");
// 生成编译任务
JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, null, null, Collections.singleton(javaFileObject));

public class ByteArrayJavaFileManager implements JavaFileManager {
    private static final Logger LOG = LoggerFactory.getLogger(ByteArrayJavaFileManager.class);


    private final StandardJavaFileManager fileManager;

    /**
     * synchronizing due to ConcurrentModificationException
     */
    private final Map<String, ByteArrayOutputStream> buffers = Collections.synchronizedMap(new LinkedHashMap<>());

    public ByteArrayJavaFileManager(StandardJavaFileManager fileManager) {
        this.fileManager = fileManager;
    }

    @Override
    public ClassLoader getClassLoader(Location location) {
        return fileManager.getClassLoader(location);
    }

    @Override
    public synchronized Iterable<JavaFileObject> list(Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException {
        return fileManager.list(location, packageName, kinds, recurse);
    }

    @Override
    public String inferBinaryName(Location location, JavaFileObject file) {
        return fileManager.inferBinaryName(location, file);
    }

    @Override
    public boolean isSameFile(FileObject a, FileObject b) {
        return fileManager.isSameFile(a, b);
    }

    @Override
    public synchronized boolean handleOption(String current, Iterator<String> remaining) {
        return fileManager.handleOption(current, remaining);
    }

    @Override
    public boolean hasLocation(Location location) {
        return fileManager.hasLocation(location);
    }

    @Override
    public JavaFileObject getJavaFileForInput(Location location, String className, Kind kind) throws IOException {

        if (location == StandardLocation.CLASS_OUTPUT) {
            boolean success;
            final byte[] bytes;
            synchronized (buffers) {
                success = buffers.containsKey(className) && kind == Kind.CLASS;
                bytes = buffers.get(className).toByteArray();
            }
            if (success) {

                return new SimpleJavaFileObject(URI.create(className), kind) {
                    @Override
                    public InputStream openInputStream() {
                        return new ByteArrayInputStream(bytes);
                    }
                };
            }
        }
        return fileManager.getJavaFileForInput(location, className, kind);
    }

    @Override
    public JavaFileObject getJavaFileForOutput(Location location, final String className, Kind kind, FileObject sibling) {
        return new SimpleJavaFileObject(URI.create(className), kind) {
            @Override
            public OutputStream openOutputStream() {
                // 字节输出流用与FileManager输出编译完成的字节码文件为字节数组
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                // 将每个需要加载的类的输出流进行缓存
                buffers.putIfAbsent(className, bos);
                return bos;
            }
        };
    }

    @Override
    public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
        return fileManager.getFileForInput(location, packageName, relativeName);
    }

    @Override
    public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {
        return fileManager.getFileForOutput(location, packageName, relativeName, sibling);
    }

    @Override
    public void flush() {
        // Do nothing
    }

    @Override
    public void close() throws IOException {
        fileManager.close();
    }

    @Override
    public int isSupportedOption(String option) {
        return fileManager.isSupportedOption(option);
    }

    public void clearBuffers() {
        buffers.clear();
    }


    public Map<String, byte[]> getAllBuffers() {
        Map<String, byte[]> ret = new LinkedHashMap<>(buffers.size() * 2);
        Map<String, ByteArrayOutputStream> compiledClasses = new LinkedHashMap<>(ret.size());
        synchronized (buffers) {
            compiledClasses.putAll(buffers);
        }
        compiledClasses.forEach((k, v) -> ret.put(k, v.toByteArray()));
        return ret;
    }

    public byte[] getBytesByClassName(String className) {
        return buffers.get(className).toByteArray();
    }
}

public static void fromJavaSourceToByteArray1() throws Exception {
    // 获取Javac编译器对象
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    // 获取文件管理器：负责管理类文件的输入输出
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
    // 创建自定义的FileManager
    ByteArrayJavaFileManager byteArrayJavaFileManager = new ByteArrayJavaFileManager(fileManager);
    // 通过源代码字符串获取到要编译的Java类源码迭代器，包括所有内部类，其中每个类都是一个JavaFileObject
    JavaFileObject javaFileObject = new SourceJavaFileObject("TestHello", "public class TestHello { public static void say(String args) { System.out.println(args); } }");

    JavaCompiler.CompilationTask task = compiler.getTask(null, byteArrayJavaFileManager, null, null, null, Collections.singletonList(javaFileObject));
    // 执行编译任务
    Boolean call = task.call();
    if (Boolean.TRUE.equals(call)) {
        byte[] testHellos = byteArrayJavaFileManager.getBytesByClassName("TestHello");
        Class<ClassLoader> classLoaderClass = ClassLoader.class;
        Method defineClass = classLoaderClass.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
        defineClass.setAccessible(true);
        Object invoke = defineClass.invoke(TestHello.class.getClassLoader(), testHellos, 0, testHellos.length);
        Class clazz = (Class) invoke;
        clazz.getMethod("say", String.class).invoke(null, "你好");

    }
}

public interface DataSource {
    /**
     * 写
     *
     * @param data 字符串
     */
    void writeData(String data);

    /**
     * 读
     *
     * @return 字符串
     */
    String readData();
}

public class FileDataSource implements DataSource {
    private final String name;

    public FileDataSource(String path) {
        this.name = path;
    }

    @Override
    public void writeData(String data) {
        File file = new File(name);
        try (OutputStream fos = new FileOutputStream(file)) {
            fos.write(data.getBytes(), 0, data.length());
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
    }

    @Override
    public String readData() {
        char[] buffer = null;
        File file = new File(name);
        try (FileReader reader = new FileReader(file)) {
            buffer = new char[(int) file.length()];
            reader.read(buffer);
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
        return new String(buffer);
    }
}

public class DataSourceDecorator implements DataSource{

    private final DataSource wrapper;

    DataSourceDecorator(DataSource source) {
        this.wrapper = source;
    }

    @Override
    public void writeData(String data) {
        wrapper.writeData(data);
    }

    @Override
    public String readData() {
        return wrapper.readData();
    }
}

public class EncryptionDecorator extends DataSourceDecorator {

    EncryptionDecorator(DataSource source) {
        super(source);
    }

    @Override
    public void writeData(String data) {
        super.writeData(encode(data));
    }

    @Override
    public String readData() {
        return decode(super.readData());
    }

    private String encode(String data) {
        byte[] result = data.getBytes();
        for (int i = 0; i < result.length; i++) {
            result[i] += (byte) 1;
        }
        return Base64.getEncoder().encodeToString(result);
    }

    private String decode(String data) {
        byte[] result = Base64.getDecoder().decode(data);
        for (int i = 0; i < result.length; i++) {
            result[i] -= (byte) 1;
        }
        return new String(result);
    }
}

public class CompressionDecorator extends DataSourceDecorator {
    private int compLevel = 6;

    public CompressionDecorator(DataSource source) {
        super(source);
    }

    public int getCompressionLevel() {
        return compLevel;
    }

    public void setCompressionLevel(int value) {
        compLevel = value;
    }

    @Override
    public void writeData(String data) {
        super.writeData(compress(data));
    }

    @Override
    public String readData() {
        return decompress(super.readData());
    }

    private String compress(String stringData) {
        byte[] data = stringData.getBytes();
        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream(512);
            DeflaterOutputStream dos = new DeflaterOutputStream(bout, new Deflater(compLevel));
            dos.write(data);
            dos.close();
            bout.close();
            return Base64.getEncoder().encodeToString(bout.toByteArray());
        } catch (IOException ex) {
            ex.printStackTrace();
            return null;
        }
    }

    private String decompress(String stringData) {
        byte[] data = Base64.getDecoder().decode(stringData);
        try (InputStream in = new ByteArrayInputStream(data);
             InflaterInputStream iin = new InflaterInputStream(in);
             ByteArrayOutputStream bout = new ByteArrayOutputStream(512)) {
            int b;
            while ((b = iin.read()) != -1) {
                bout.write(b);
            }
            return bout.toString();
        } catch (IOException ex) {
            return null;
        }
    }
}

public class DecoratorTest {

    public static void main(String[] args) {
        String salaryRecords = "装饰模式真厉害啊";
        DataSourceDecorator encoded = new CompressionDecorator(
                new EncryptionDecorator(
                        new FileDataSource("./target/OutputDemo.txt")
                )
        );
        encoded.writeData(salaryRecords);
        DataSource plain = new FileDataSource("./target/OutputDemo.txt");

        System.out.println("- Input ----------------");
        System.out.println(salaryRecords);
        System.out.println("- Encoded --------------");
        System.out.println(plain.readData());
        System.out.println("- Decoded --------------");
        System.out.println(encoded.readData());
    }
}

- Input ----------------
装饰模式真厉害啊
- Encoded --------------
Zkt4Q0hCRW8wLGpraWZubXRQYnBwZlg5ayxmZG8sWFBqZlh2dCxYV2p1bUVGU1o+
- Decoded --------------
装饰模式真厉害啊

public interface Cinema {

    /**
     * 播放电影
     *
     * @param filmName name
     */
    void play(String filmName);
}

public class DefaultCinema implements Cinema {

    @Override
    public void play(String filmName) {
        System.out.println("现在正在播放电影：" + filmName);
    }
}

public class CinemaProxy implements Cinema {

    private final Cinema cinema;

    public CinemaProxy() {
        this.cinema = new DefaultCinema();
    }

    @Override
    public void play(String filmName) {
        CinemaProxyTask.playStartAd();
        cinema.play(filmName);
        CinemaProxyTask.playEndAd();
    }
}

public class CinemaProxyTask {

    public static void playStartAd() {
        System.out.println("正在播放片头广告");
    }

    public static void playEndAd() {
        System.out.println("正在播放片尾广告");
    }
}

public class MainTest {

    public static void main(String[] args) {
        String filmName = "中国医生";
        staticProxy(filmName);
    }

    public static void staticProxy(String filmName) {
        Cinema proxyCinema = new CinemaProxy();
        proxyCinema.play(filmName);
    }
}

public class JdkCinemaProxy implements InvocationHandler {

    private final Object object;

    public JdkCinemaProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object invoke = null;
        if (method.getName().equals("play")) {
            CinemaProxyTask.playStartAd();
            invoke = method.invoke(object, args);
            CinemaProxyTask.playEndAd();
        }
        return invoke;
    }
}

public class MainTest {

    public static void main(String[] args) {
        String filmName = "中国医生";
        dynamicJdkProxy(filmName);
    }

    public static void dynamicJdkProxy(String filmName) {
      // 保存动态生成的代理类
        System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
        DefaultCinema defaultCinema = new DefaultCinema();
        JdkCinemaProxy jdkCinemaProxy = new JdkCinemaProxy(defaultCinema);
      // 动态生成代理类，返回的Object 就是生成的代理类实例
        Object o = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class[]{Cinema.class}, jdkCinemaProxy);
        Cinema cinema = (Cinema) o;
        cinema.play(filmName);
    }
}

public final class $Proxy0 extends Proxy implements Cinema {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void play(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("top.oneyoung.design.proxy.Cinema").getMethod("play", Class.forName("java.lang.String"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}