import java.awt.*;
import javax.swing.*;
import javax.swing.tree.*;

public class ChangeAllCellRender {
    JFrame jf = new JFrame("改变所有节点的外观");
    JTree tree;
    // 定义几个初始节点
    DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
    DefaultMutableTreeNode guangdong = new DefaultMutableTreeNode("广东");
    DefaultMutableTreeNode guangxi = new DefaultMutableTreeNode("广西");
    DefaultMutableTreeNode foshan = new DefaultMutableTreeNode("佛山");
    DefaultMutableTreeNode shantou = new DefaultMutableTreeNode("汕头");
    DefaultMutableTreeNode guilin = new DefaultMutableTreeNode("桂林");
    DefaultMutableTreeNode nanning = new DefaultMutableTreeNode("南宁");

    public void init() {
        // 通过add()方法建立树节点之间的父子关系
        guangdong.add(foshan);
        guangdong.add(shantou);
        guangxi.add(guilin);
        guangxi.add(nanning);
        root.add(guangdong);
        root.add(guangxi);
        // 以根节点创建树
        tree = new JTree(root);
        // 创建一个DefaultTreeCellRender对象
        DefaultTreeCellRenderer cellRender = new DefaultTreeCellRenderer();
        // 设置非选定节点的背景色。
        cellRender.setBackgroundNonSelectionColor(new Color(220, 220, 220));
        // 设置节点在选中状态下的背景颜色。
        cellRender.setBackgroundSelectionColor(new Color(140, 140, 140));
        // 设置选中状态下节点的边框颜色。
        cellRender.setBorderSelectionColor(Color.BLACK);
        // 设置处于折叠状态下非叶子节点的图标。
        cellRender.setClosedIcon(new ImageIcon("icon/close.gif"));
        // 设置节点文本的字体。
        cellRender.setFont(new Font("SansSerif", Font.BOLD, 16));
        // 设置叶子节点的图标。
        cellRender.setLeafIcon(new ImageIcon("icon/leaf.png"));
        // 设置处于展开状态下非叶子节点的图标。
        cellRender.setOpenIcon(new ImageIcon("icon/open.gif"));
        // 设置绘制非选中状态下节点文本的颜色。
        cellRender.setTextNonSelectionColor(new Color(255, 0, 0));
        // 设置绘制选中状态下节点文本的颜色。
        cellRender.setTextSelectionColor(new Color(0, 0, 255));
        tree.setCellRenderer(cellRender);
        // 设置是否显示根节点的“展开/折叠”图标,默认是false
        tree.setShowsRootHandles(true);
        // 设置节点是否可见,默认是true
        tree.setRootVisible(true);
        jf.add(new JScrollPane(tree));
        jf.pack();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setVisible(true);
    }

    public static void main(String[] args) {
        new ChangeAllCellRender().init();
    }
}

import javax.swing.*;
import javax.swing.tree.*;

public class SelectJTree {
    JFrame jf = new JFrame("监听树的选择事件");
    JTree tree;
    // 定义几个初始节点
    DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
    DefaultMutableTreeNode guangdong = new DefaultMutableTreeNode("广东");
    DefaultMutableTreeNode guangxi = new DefaultMutableTreeNode("广西");
    DefaultMutableTreeNode foshan = new DefaultMutableTreeNode("佛山");
    DefaultMutableTreeNode shantou = new DefaultMutableTreeNode("汕头");
    DefaultMutableTreeNode guilin = new DefaultMutableTreeNode("桂林");
    DefaultMutableTreeNode nanning = new DefaultMutableTreeNode("南宁");
    JTextArea eventTxt = new JTextArea(5, 20);

    public void init() {
        // 通过add()方法建立树节点之间的父子关系
        guangdong.add(foshan);
        guangdong.add(shantou);
        guangxi.add(guilin);
        guangxi.add(nanning);
        root.add(guangdong);
        root.add(guangxi);
        // 以根节点创建树
        tree = new JTree(root);
        // 设置只能选择一个TreePath
        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        // 添加监听树节点选择事件的监听器
        // 当JTree中被选择节点发生改变时，将触发该方法
        tree.addTreeSelectionListener(e -> {
            if (e.getOldLeadSelectionPath() != null)
                eventTxt.append("原选中的节点路径：" + e.getOldLeadSelectionPath().toString() + "\n");
            eventTxt.append("新选中的节点路径：" + e.getNewLeadSelectionPath().toString() + "\n");
        });
        // 设置是否显示根节点的“展开/折叠”图标,默认是false
        tree.setShowsRootHandles(true);
        // 设置根节点是否可见,默认是true
        tree.setRootVisible(true);
        Box box = new Box(BoxLayout.X_AXIS);
        box.add(new JScrollPane(tree));
        box.add(new JScrollPane(eventTxt));
        jf.add(box);
        jf.pack();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setVisible(true);
    }

    public static void main(String[] args) {
        new SelectJTree().init();
    }
}

import java.util.Arrays;

public class Num2Rmb {
    private String[] hanArr = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
    private String[] unitArr = { "十", "百", "千" };

    /**
     * 把一个浮点数分解成整数部分和小数部分字符串
     * 
     * @param num 需要被分解的浮点数
     * @return 分解出来的整数部分和小数部分。第一个数组元素是整数部分，第二个数组元素是小数部分。
     */
    private String[] divide(double num) {
        // 将一个浮点数强制类型转换为long，即得到它的整数部分
        long zheng = (long) num;
        // 浮点数减去整数部分，得到小数部分，小数部分乘以100后再取整得到2位小数
        long xiao = Math.round((num - zheng) * 100);
        // 下面用了2种方法把整数转换为字符串
        return new String[] { zheng + "", String.valueOf(xiao) };
    }

    /**
     * 把一个四位的数字字符串变成汉字字符串
     * 
     * @param numStr 需要被转换的四位的数字字符串
     * @return 四位的数字字符串被转换成的汉字字符串。
     */
    private String toHanStr(String numStr) {
        String result = "";
        int numLen = numStr.length();
        // 依次遍历数字字符串的每一位数字
        for (int i = 0; i < numLen; i++) {
            // 把char型数字转换成的int型数字，因为它们的ASCII码值恰好相差48
            // 因此把char型数字减去48得到int型数字，例如'4'被转换成4。
            int num = numStr.charAt(i) - 48;
            // 如果不是最后一位数字，而且数字不是零，则需要添加单位（千、百、十）
            if (i != numLen - 1 && num != 0) {
                result += hanArr[num] + unitArr[numLen - 2 - i];
            }
            // 否则不要添加单位
            else {
                result += hanArr[num];
            }
        }
        return result;
    }

    public static void main(String[] args) {
        Num2Rmb nr = new Num2Rmb();
        // 测试把一个浮点数分解成整数部分和小数部分
        System.out.println(Arrays.toString(nr.divide(236711125.123)));
        // 测试把一个四位的数字字符串变成汉字字符串
        System.out.println(nr.toHanStr("609"));
        // System.out.println(nr.toHanStr("6092"));
    }
}

import java.io.*;

public class Gobang {
    // 定义棋盘的大小
    private static int BOARD_SIZE = 15;
    // 定义一个二维数组来充当棋盘
    private String[][] board;

    public void initBoard() {
        // 初始化棋盘数组
        board = new String[BOARD_SIZE][BOARD_SIZE];
        // 把每个元素赋为"╋"，用于在控制台画出棋盘
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                board[i][j] = "╋";
            }
        }
    }

    // 在控制台输出棋盘的方法
    public void printBoard() {
        // 打印每个数组元素
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                // 打印数组元素后不换行
                System.out.print(board[i][j]);
            }
            // 每打印完一行数组元素后输出一个换行符
            System.out.print("\n");
        }
    }

    public static void main(String[] args) throws Exception {
        Gobang gb = new Gobang();
        gb.initBoard();
        gb.printBoard();
        // 这是用于获取键盘输入的方法
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String inputStr = null;
        // br.readLine()：每当在键盘上输入一行内容按回车，用户刚输入的内容将被br读取到。
        while ((inputStr = br.readLine()) != null) {
            // 将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串
            String[] posStrArr = inputStr.split(",");
            // 将2个字符串转换成用户下棋的座标
            int xPos = Integer.parseInt(posStrArr[0]);
            int yPos = Integer.parseInt(posStrArr[1]);
            // 把对应的数组元素赋为"●"。
            gb.board[yPos - 1][xPos - 1] = "●";
            /*
             * 电脑随机生成2个整数，作为电脑下棋的座标，赋给board数组。 还涉及 1.座标的有效性，只能是数字，不能超出棋盘范围 2.如果下的棋的点，不能重复下棋。
             * 3.每次下棋后，需要扫描谁赢了
             */
            gb.printBoard();
            System.out.println("请输入您下棋的座标，应以x,y的格式：");
        }
    }
}

import java.util.Arrays;

public class ArraysTest {
    public static void main(String[] args) {
        // 定义一个a数组
        int[] a = new int[] { 3, 4, 5, 6 };
        // 定义一个a2数组
        int[] a2 = new int[] { 3, 4, 5, 6 };
        // a数组和a2数组的长度相等，每个元素依次相等，将输出true
        System.out.println("a数组和a2数组是否相等：" + Arrays.equals(a, a2));
        // 通过复制a数组，生成一个新的b数组
        int[] b = Arrays.copyOf(a, 6);
        System.out.println("a数组和b数组是否相等：" + Arrays.equals(a, b));
        // 输出b数组的元素，将输出[3, 4, 5, 6, 0, 0]
        System.out.println("b数组的元素为：" + Arrays.toString(b));
        // 将b数组的第3个元素（包括）到第5个元素（不包括）赋为1
        Arrays.fill(b, 2, 4, 1);
        // 输出b数组的元素，将输出[3, 4, 1, 1, 0, 0]
        System.out.println("b数组的元素为：" + Arrays.toString(b));
        // 对b数组进行排序
        Arrays.sort(b);
        // 输出b数组的元素，将输出[0, 0, 1, 1, 3, 4]
        System.out.println("b数组的元素为：" + Arrays.toString(b));
    }
}

import java.util.Arrays;
import java.util.function.*;

public class ArraysTest2 {
    public static void main(String[] args) {
        int[] arr1 = new int[] { 3, -4, 25, 16, 30, 18 };
        // 对数组arr1进行并发排序
        Arrays.parallelSort(arr1);
        System.out.println("arr1="+Arrays.toString(arr1));


        int[] arr2 = new int[] { 3, -4, 25, 16, 30, 18 };
        Arrays.parallelPrefix(arr2, new IntBinaryOperator() {
            // left代表数组中前一个所索引处的元素，计算第一个元素时，left为1
            // right代表数组中当前索引处的元素
            public int applyAsInt(int left, int right) {
                return left * right;
            }
        });
        System.out.println("arr2="+Arrays.toString(arr2));


        int[] arr3 = new int[5];
        Arrays.parallelSetAll(arr3, new IntUnaryOperator() {
            // operand代表正在计算的元素索引
            public int applyAsInt(int operand) {
                return operand * 5;
            }       
        });
        System.out.println("arr3="+Arrays.toString(arr3));
    }
}

[1*3=3,3*-4=-12,-12*25=-300,-300*16=-48000,-48000*30=-144000,-144000*18=-2592000]

[0, 5, 10, 15, 20]

type[][] arrName;

arrName = new type [length][];

// 定义一个二维数组
int[][] a;
// 把a当成一维数组进行初始化，初始化a是一个长度为4的数组
// a数组的数组元素又是引用类型
a = new int[4][];
// 把a数组当成一维数组，遍历a数组的每个数组元素
for (int i = 0, len = a.length; i < len; i++) {
    System.out.println(a[i]);
}
// 初始化a数组的第一个元素
a[0] = new int[2];
// 访问a数组的第一个元素所指数组的第二个元素
a[0][1] = 6;
// a数组的第一个元素是一个一维数组，遍历这个一维数组
for (int i = 0, len = a[0].length; i < len; i++) {
    System.out.println(a[0][i]);
}

// 同时初始化二维数组的2个维数
int[][] b = new int[3][4];

// 使用静态初始化的语法来初始化一个二维数组
String[][] str1 = new String[][] { new String[3], new String[] { "hello" } };
// 使用简化的静态初始化语法来初始化二维数组
String[][] str2 = { new String[3], new String[] { "hello" } };
System.out.println(str1[1][0]);
System.out.println(str2[1][0]);

class Person {
    public int age; // 年龄
    public double height; // 身高
    // 定义一个info方法

    public void info() {
        System.out.println("我的年龄是：" + age + "，我的身高是：" + height);
    }
}

public class ReferenceArrayTest {
    public static void main(String[] args) {
        // 定义一个students数组变量，其类型是Person[]
        Person[] students;
        // 执行动态初始化
        students = new Person[2];
        // 创建一个Person实例，并将这个Person实例赋给zhang变量
        Person zhang = new Person();
        // 为zhang所引用的Person对象的age、height赋值
        zhang.age = 15;
        zhang.height = 158;
        // 创建一个Person实例，并将这个Person实例赋给lee变量
        Person lee = new Person();
        // 为lee所引用的Person对象的age、height赋值
        lee.age = 16;
        lee.height = 161;
        // 将zhang变量的值赋给第一个数组元素
        students[0] = zhang;
        // 将lee变量的值赋给第二个数组元素
        students[1] = lee;
        // 下面两行代码的结果完全一样，因为lee
        // 和students[1]指向的是同一个Person实例。
        lee.info();
        students[1].info();
    }
}

public class PrimitiveArrayTest {
    public static void main(String[] args) {
        // 定义一个int[]类型的数组变量
        int[] iArr;
        // 动态初始化数组，数组长度为5
        iArr = new int[5];
        // 采用循环方式为每个数组元素赋值。
        for (int i = 0; i < iArr.length; i++) {
            iArr[i] = i + 10;
        }
    }
}

public class ArrayInRam
{
    public static void main(String[] args)
    {
        // 定义并初始化数组，使用静态初始化
        int[] a = {5, 7 , 20};
        // 定义并初始化数组，使用动态初始化
        int[] b = new int[4];
        // 输出b数组的长度
        System.out.println("b数组的长度为：" + b.length);
        // 循环输出a数组的元素
        for (int i = 0 ,len = a.length; i < len ; i++ )
        {
            System.out.println(a[i]);
        }
        // 循环输出b数组的元素
        for (int i = 0 , len = b.length; i < len ; i++ )
        {
            System.out.println(b[i]);
        }
        // 因为a是int[]类型，b也是int[]类型，所以可以将a的值赋给b。
        // 也就是让b引用指向a引用指向的数组
        b = a;
        // 再次输出b数组的长度
        System.out.println("b数组的长度为：" + b.length);
    }
}

for(type variableName : arrayName){
    // variableName自动迭代访问每个元素
}

public class ForEachTest {
    public static void main(String[] args) {
        String[] books = { "Hello", "World", "Java" };
        // 使用foreach循环来遍历数组元素，
        // 其中book将会自动迭代每个数组元素
        for (String book : books) {
            System.out.println(book);
        }
    }
}

public class ForEachErrorTest {
    public static void main(String[] args) {
        String[] books = { "Hello", "World", "Java" };
        // 使用foreach循环来遍历数组元素，其中book将会自动迭代每个数组元素
        for (String book : books) {
            book = "JSP";
            System.out.println(book);
        }
        System.out.println(books[0]);
    }
}