public class ArrayListForEachRemoveTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
    
        // 第40行
        for (Integer integer : list) {
            list.remove(1);
        }
    }
}

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at com.github.test.ArrayListForEachRemoveTest.main(ArrayListForEachRemoveTest.java:40)

package com.github.test;

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

public class ArrayListForEachRemoveTest {
    public ArrayListForEachRemoveTest() {
    }

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();

        for(int i = 0; i < 10; ++i) {
            list.add(i);
        }

        Iterator var4 = list.iterator();

        while(var4.hasNext()) {
            Integer integer = (Integer)var4.next();
            list.remove(1);
        }

    }
}

private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
        // ...
        public E next() {
            checkForComodification();
            // ...
        }
  
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

}

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

public class TreeNode {
    public int value;
    public TreeNode left;
    public TreeNode right;
    public int height;

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

    @Override
    public String toString() {
        return "TreeNode{" +
                "value=" + value +
                '}';
    }
}

/**
 * 先序打印
 * parent -> left -> right
 */
public static void printPreorder(TreeNode head) {
    if (head == null) return;
    System.out.print(head.value + ",");
    printPreorder(head.left);
    printPreorder(head.right);
}

/**
 * 中序打印
 * left -> parent -> right
 */
public static void printInorder(TreeNode head) {
    if (head == null) return;
    printInorder(head.left);
    System.out.print(head.value + ",");
    printInorder(head.right);
}

/**
 * 后序打印
 * left -> right -> parent
 */
public static void printPostorder(TreeNode head) {
    if (head == null) return;
    printPostorder(head.left);
    printPostorder(head.right);
    System.out.print(head.value + ",");
}

public static TreeNode find(TreeNode node, int val) {
    if (node == null) {
        return null;
    }

    if (val < node.value) {
        return find(node.left, val);
    } else if (val > node.value) {
        return find(node.right, val);
    } else {
        return node;
    }
}

public static TreeNode insert(TreeNode head, int k) {
    if (head == null) {
        head = new TreeNode(k);
    }
    if (k < head.value) {
        head.left = insert(head.left, k);
    } else if (k > head.value) {
        head.right = insert(head.right, k);
    }

    return head;
}

public static TreeNode findMin(TreeNode node) {
    if (node.left == null) return node;
    return findMin(node.left);
}

/**
 * @author JiHongYuan
 * @date 2021/6/18 14:34
 */
public class ExpressTree {
    public static void main(String[] args) {
        String expression = "4.99 * 1.06 + 5.99 + 6.99 * 1.06";
        List<String> stringList = SuffixCalc.infixTransformSuffix(expression);


        Stack<Node<String>> stack = new Stack<>();
        for (String str : stringList) {
            if (SuffixCalc.SymbolEnum.getSymbolEnumByString(str) != SuffixCalc.SymbolEnum.NONE) {
                Node<String> parent = new Node<>(str, stack.pop(), stack.pop());
                stack.push(parent);
            } else {
                stack.push(new Node<>(str, null, null));
            }
        }

        Node<String> root = stack.pop();
        printInorder(root);
        System.out.println();
        System.out.println(calc(root).toString());
    }

    public static <E> void printInorder(Node<E> head) {
        if (head == null) return;
        System.out.print("( ");
        printInorder(head.left);
        System.out.print(head.item + " ");
        printInorder(head.right);
        System.out.print(" ) ");
    }

    public static <E> E calc(Node<E> node) {
        if (node == null) return null;

        SuffixCalc.SymbolEnum symbol = SuffixCalc.SymbolEnum.getSymbolEnumByString(node.item.toString());

        if (symbol != SuffixCalc.SymbolEnum.NONE) {
            BigDecimal n1 = new BigDecimal(calc(node.left).toString());
            BigDecimal n2 = new BigDecimal(calc(node.right).toString());

            BigDecimal result;
            switch (symbol) {
                case ADD:
                    result = n1.add(n2);
                    break;
                case SUB:
                    result = n1.subtract(n2);
                    break;
                case MUL:
                    result = n1.multiply(n2);
                    break;
                case DIV:
                    result = n1.divide(n2);
                    break;
                default:
                    result = BigDecimal.ZERO;
            }
            node.item = (E) result.toString();
        }

        return node.item;
    }

    private static class Node<E> {
        E item;
        Node<E> left;
        Node<E> right;


        public Node(E item, Node<E> left, Node<E> right) {
            this.item = item;
            this.left = left;
            this.right = right;
        }


        @Override
        public String toString() {
            return "Node{" +
                    "item=" + item +
                    ", left=" + left +
                    ", right=" + right +
                    '}';
        }

    }

}

public static TreeNode singleRotateWithLeft(TreeNode k2) {
    TreeNode k1;
    k1 = k2.left;
    k2.left = k1.right;
    k1.right = k2;

    k1.height = Math.max(TreeUtil.height(k1.left), TreeUtil.height(k1.right)) + 1;
    k2.height = Math.max(TreeUtil.height(k2.left), TreeUtil.height(k2.right)) + 1;
    return k1;
}

public static TreeNode singleRotateWithRight(TreeNode k2) {
    TreeNode k1;

    k1 = k2.right;
    k2.right = k1.left;
    k1.left = k2;

    k1.height = Math.max(TreeUtil.height(k1.left), TreeUtil.height(k1.right)) + 1;
    k2.height = Math.max(TreeUtil.height(k2.left), TreeUtil.height(k2.right)) + 1;
    return k1;
}

public static TreeNode doubleRotateWithLeft(TreeNode k3) {
     k3.left = singleRotateWithRight(k3.left);
     return singleRotateWithLeft(k3);
 }

public static TreeNode doubleRotateWithRight(TreeNode k3) {
    k3.right = singleRotateWithLeft(k3.right);
    return singleRotateWithRight(k3);
}

public static TreeNode insert(TreeNode T, int val) {
    if (T == null) {
        T = new TreeNode(val);
    } else if (val < T.value) {
        // 插入在左边
        T.left = insert(T.left, val);

        // 找到破坏平衡的节点
        if (height(T.left) - height(T.right) == 2) {
            if (val < T.left.value) {
                // 左左条件 单旋转
                T = singleRotateWithLeft(T);
            } else {
                // 左右条件 双旋转
                T = doubleRotateWithLeft(T);
            }
        }
    } else if (val > T.value) {
        T.right = insert(T.right, val);
        if (height(T.right) - height(T.left) == 2) {
            if (val > T.right.value) {
                T = singleRotateWithRight(T);
            } else {
                T = doubleRotateWithRight(T);
            }
        }
    }
    // 重新计算节点高度
    T.height = Math.max(height(T.left), height(T.right)) + 1;
    return T;
}

/**
 * @author JiHongYuan
 * @date 2021/6/17 17:51
 */
public class AvlTree<E extends Comparable<E>> {
    Node<E> root;

    private static class Node<E> {
        E item;
        int height;
        Node<E> left;
        Node<E> right;


        public Node(E item, Node<E> left, Node<E> right) {
            this.item = item;
            this.left = left;
            this.right = right;
        }


        @Override
        public String toString() {
            return "Node{" +
                    "item=" + item +
                    ", height=" + height +
                    ", left=" + left +
                    ", right=" + right +
                    '}';
        }
    }

    public int height(Node<E> node) {
        if (node == null) {
            return -1;
        }
        return node.height;
    }

    public boolean add(E e) {
        root = insert(root, e);
        return true;
    }

    public Node<E> get(E item) {
        return node(root, item);
    }

    /**
     * return specified element item.
     */
    Node<E> node(Node<E> node, E item) {
        if (item.compareTo(node.item) < 0) {
            return node(node.left, item);
        } else if (item.compareTo(node.item) > 0) {
            return node(node.right, item);
        } else {
            return node;
        }
    }

    private Node<E> singleRotateWithLeft(Node<E> k2) {
        Node<E> k1;
        k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;

        k1.height = Math.max(height(k1.left), height(k1.right)) + 1;
        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        return k1;
    }

    private Node<E> singleRotateWithRight(Node<E> k2) {
        Node<E> k1;

        k1 = k2.right;
        k2.right = k1.left;
        k1.left = k2;

        k1.height = Math.max(height(k1.left), height(k1.right)) + 1;
        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        return k1;
    }

    private Node<E> doubleRotateWithLeft(Node<E> k3) {
        k3.left = singleRotateWithRight(k3.left);
        return singleRotateWithLeft(k3);
    }

    private Node<E> doubleRotateWithRight(Node<E> k3) {
        k3.right = singleRotateWithLeft(k3.right);
        return singleRotateWithRight(k3);
    }

    private Node<E> insert(Node<E> node, E item) {
        if (node == null) {
            node = new Node<>(item, null, null);
        } else if (item.compareTo(node.item) < 0) {
            // 插入在左边
            node.left = insert(node.left, item);

            // 找到破坏平衡的节点
            if (height(node.left) - height(node.right) == 2) {
                if (item.compareTo(node.left.item) < 0) {
                    // 左左条件 单旋转
                    node = singleRotateWithLeft(node);
                } else {
                    // 左右条件 双旋转
                    node = doubleRotateWithLeft(node);
                }
            }
        } else if (item.compareTo(node.item) > 0) {
            node.right = insert(node.right, item);
            if (height(node.right) - height(node.left) == 2) {
                if (item.compareTo(node.right.item) > 0) {
                    node = singleRotateWithRight(node);
                } else {
                    node = doubleRotateWithRight(node);
                }
            }
        }
        // 重新计算节点高度
        node.height = Math.max(height(node.left), height(node.right)) + 1;
        return node;
    }

    private static void writeArray(Node currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
        // 保证输入的树不为空
        if (currNode == null) return;
        // 先将当前节点保存到二维数组中
        res[rowIndex][columnIndex] = String.valueOf(currNode.item);

        // 计算当前位于树的第几层
        int currLevel = ((rowIndex + 1) / 2);
        // 若到了最后一层，则返回
        if (currLevel == treeDepth) return;
        // 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
        int gap = treeDepth - currLevel - 1;

        // 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
        if (currNode.left != null) {
            res[rowIndex + 1][columnIndex - gap] = "/";
            writeArray(currNode.left, rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
        }

        // 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
        if (currNode.right != null) {
            res[rowIndex + 1][columnIndex + gap] = "\\";
            writeArray(currNode.right, rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
        }
    }

    // 用于获得树的层数
    private int getTreeDepth(Node<E> root) {
        return root == null ? 0 : (1 + Math.max(getTreeDepth(root.left), getTreeDepth(root.right)));
    }

    public void show() {
        // 得到树的深度
        int treeDepth = getTreeDepth(root);

        // 最后一行的宽度为2的（n - 1）次方乘3，再加1
        // 作为整个二维数组的宽度
        int arrayHeight = treeDepth * 2 - 1;
        int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
        // 用一个字符串数组来存储每个位置应显示的元素
        String[][] res = new String[arrayHeight][arrayWidth];
        // 对数组进行初始化，默认为一个空格
        for (int i = 0; i < arrayHeight; i++) {
            for (int j = 0; j < arrayWidth; j++) {
                res[i][j] = " ";
            }
        }

        // 从根节点开始，递归处理整个树
        // res[0][(arrayWidth + 1)/ 2] = (char)(root.val + '0');
        writeArray(root, 0, arrayWidth / 2, res, treeDepth);

        // 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
        for (String[] line : res) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < line.length; i++) {
                sb.append(line[i]);
                if (line[i].length() > 1 && i <= line.length - 1) {
                    i += line[i].length() > 4 ? 2 : line[i].length() - 1;
                }
            }
            System.out.println(sb.toString());
            
        }
    }
}


/**
 * @author JiHongYuan
 * @date 2021/6/17 18:24
 */
public class AvlTreeTest {
  public static void main(String[] args) {
    AvlTree<Integer> avlTree = new AvlTree<>();

    Integer[] integers = {5, 4, 6, 7, 8, 11};
    for (Integer integer : integers) {
      avlTree.add(integer);
    }
    avlTree.show();

    System.out.println(avlTree.get(5));
    avlTree.show();

  }
}

package com.github.数据结构与算法分析.stack;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * @author JiHongYuan
 * @date 2021/6/14 13:45
 */
public class SuffixCalc {

    public static void main(String[] args) {
        String expression = "4.99 * 1.06 + 5.99 + 6.99 * 1.06";
        List<String> suffixList = infixTransformSuffix(expression);

        Stack<BigDecimal> stack = new Stack<>();
        for (String s : suffixList) {
            SymbolEnum symbol = SymbolEnum.getSymbolEnumByString(s);
            if (symbol == SymbolEnum.NONE) {
                stack.push(new BigDecimal(s));
            } else {
                BigDecimal i1 = stack.pop();
                BigDecimal i2 = stack.pop();
                BigDecimal iNew;
                switch (symbol) {
                    case ADD:
                        iNew = i1.add(i2);
                        break;
                    case SUB:
                        iNew = i1.subtract(i2);
                        break;
                    case MUL:
                        iNew = i1.multiply(i2);
                        break;
                    case DIV:
                        iNew = i1.divide(i2);
                        break;
                    default:
                        iNew = new BigDecimal("0.00");
                }
                stack.push(iNew);
            }
        }

        System.out.println(stack.pop());
    }

    /**
     * 中缀表达式转换成后缀表达式
     *
     * @param expression 中缀表达式
     * @return 后缀表达式
     */
    public static List<String> infixTransformSuffix(String expression) {
        List<String> suffixList = new ArrayList<>();

        Stack<SymbolEnum> stack = new Stack<>();
        for (String s : expression.split(SymbolEnum.NONE.symbol)) {
            SymbolEnum symbol = SymbolEnum.getSymbolEnumByString(s);
            if (symbol == SymbolEnum.NONE) {
                suffixList.add(s);
            } else {
                if (symbol == SymbolEnum.RIGHT_PARENTHESIS) {
                    suffixFiller(stack, suffixList, SymbolEnum.RIGHT_PARENTHESIS);
                } else if (stack.isEmpty() || stack.peek().priority > symbol.priority) {
                    stack.push(symbol);
                } else {
                    suffixFiller(stack, suffixList, SymbolEnum.NONE);
                    stack.push(symbol);
                }
            }
        }
        suffixFiller(stack, suffixList, SymbolEnum.NONE);
        return suffixList;
    }

    /**
     * 后缀表达式填充
     *
     * @param stack      数据源栈
     * @param suffixList 填充目标列表
     * @param symbol     当前表达式
     */
    public static void suffixFiller(Stack<SymbolEnum> stack, List<String> suffixList, SymbolEnum symbol) {
        while (!stack.isEmpty()) {
            SymbolEnum top = stack.peek();
            if (SymbolEnum.LEFT_PARENTHESIS == top) {
                if (symbol == SymbolEnum.RIGHT_PARENTHESIS) stack.pop();

                return;
            }
            suffixList.add(stack.pop().symbol);
        }
    }

    enum SymbolEnum {
        /**
         *
         */
        ADD("+", 4),
        SUB("-", 4),
        MUL("*", 3),
        DIV("/", 3),
        LEFT_PARENTHESIS("(", 1),
        RIGHT_PARENTHESIS(")", 1),
        NONE(" ", -1);
        String symbol;
        int priority;

        SymbolEnum(String symbol, int priority) {
            this.symbol = symbol;
            this.priority = priority;
        }

        public static SymbolEnum getSymbolEnumByString(String s) {
            for (SymbolEnum value : SymbolEnum.values()) {
                if (s.equals(value.symbol)) {
                    return value;
                }
            }
            return NONE;
        }
    }

}

# config.properties
username = root
password = 123456

// 解析XML配置
Properties settings = settingsAsProperties(root.evalNode("settings"));
// 设置VFS的实现
loadCustomVfs(settings);
// 设置自定义日志
loadCustomLogImpl(settings);
// ...
// 配置设置默认属性
settingsElement(settings);

private Properties settingsAsProperties(XNode context) {
    if (context == null) {
        return new Properties();
    }
    // 读取配置信息
    Properties props = context.getChildrenAsProperties();
    // Check that all settings are known to the configuration class
    
    // 验证 Configuration中是否存在setting标签中set name属性方法。
    MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
    for (Object key : props.keySet()) {
        if (!metaConfig.hasSetter(String.valueOf(key))) {
            throw new BuilderException("The setting " + key + " is not known.  Make sure you spelled it correctly (case sensitive).");
        }
    }
    return props;
}

typeAliasesElement(root.evalNode("typeAliases"));

private void typeAliasesElement(XNode parent) {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            // 把整个包名下所有对象注册别名
            if ("package".equals(child.getName())) {
                String typeAliasPackage = child.getStringAttribute("name");
                configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
            } else {
                // 单个对象注册
                String alias = child.getStringAttribute("alias");
                String type = child.getStringAttribute("type");
                try {
                    Class<?> clazz = Resources.classForName(type);
                    if (alias == null) {
                        typeAliasRegistry.registerAlias(clazz);
                    } else {
                        typeAliasRegistry.registerAlias(alias, clazz);
                    }
                } catch (ClassNotFoundException e) {
                    throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
                }
            }
        }
    }
}

public class ExampleObjectFactory extends DefaultObjectFactory {
    @Override
    public Object create(Class type) {
        return super.create(type);
    }
    @Override
    public void setProperties(Properties properties) {
        System.out.println(properties);
        super.setProperties(properties);
    }
    @Override
    public <T> boolean isCollection(Class<T> type) {
        return Collection.class.isAssignableFrom(type);
    }
}
// print
// -------------------------------
{someProperty=100}
// -------------------------------

private void objectFactoryElement(XNode context) throws Exception {
    if (context != null) {
        String type = context.getStringAttribute("type");
        Properties properties = context.getChildrenAsProperties();
        // 根据类型，创建ExampleObjectFactory
        ObjectFactory factory = (ObjectFactory) resolveClass(type).getDeclaredConstructor().newInstance();
        // 调用set方法
        factory.setProperties(properties);
        // 设置到configuration中
        configuration.setObjectFactory(factory);
    }
}

private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            String interceptor = child.getStringAttribute("interceptor");
            // plugin -> property
            Properties properties = child.getChildrenAsProperties();
            // 创建plugin 拦截器
            Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).getDeclaredConstructor().newInstance();
            interceptorInstance.setProperties(properties);
            // 添加到configuration拦截器链中
            configuration.addInterceptor(interceptorInstance);
        }
    }
}

private void environmentsElement(XNode context) throws Exception {
    if (context != null) {
        if (environment == null) {
            // 获取当前环境名称
            environment = context.getStringAttribute("default");
        }
        for (XNode child : context.getChildren()) {
            String id = child.getStringAttribute("id");
            // 判断当前默认环境 和 environmentId是否相同 
            if (isSpecifiedEnvironment(id)) {
                // 解析事务管理，创建TransactionFactory实例
                TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
                // 解析数据源
                DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
                DataSource dataSource = dsFactory.getDataSource();
                // 构建环境
                Environment.Builder environmentBuilder = new Environment.Builder(id)
                    .transactionFactory(txFactory)
                    .dataSource(dataSource);
                // 赋值
                configuration.setEnvironment(environmentBuilder.build());
            }
        }
    }
}

databaseIdProviderElement(root.evalNode("databaseIdProvider"));
private void databaseIdProviderElement(XNode context) throws Exception {
    DatabaseIdProvider databaseIdProvider = null;
    if (context != null) {
        String type = context.getStringAttribute("type");
        // awful patch to keep backward compatibility
        if ("VENDOR".equals(type)) {
            type = "DB_VENDOR";
        }
        Properties properties = context.getChildrenAsProperties();
        // 创建VendorDatabaseIdProvider对象
        databaseIdProvider = (DatabaseIdProvider) resolveClass(type).getDeclaredConstructor().newInstance();
        databaseIdProvider.setProperties(properties);
    }
    Environment environment = configuration.getEnvironment();
    if (environment != null && databaseIdProvider != null) {
        // 设置当前数据源 对于databaseId
        String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
        configuration.setDatabaseId(databaseId);
    }
  }