如何在Java中创建生成随机值的方法？

我有二进制搜索树代码（这是硬代码）做（插入，删除，最大，最小，排序和查找），我想学习的BST效率。我想创建一个随机方法来生成1000个数字，而不是输入数字。 如何创建此方法

public class BinarySearchTree {


private Node root; 

    private static class Node {
        Node parent;
        Node left;
        Node right;
        int data;

        Node( int data ) {
            this.data = data;
        }

        @Override
        public String toString( ) {
            return "" + data;
        }
    }


    public void insert( int data ) {
        root = insert( root, data );
    }

    public Node insert( Node node, int data ) {
        if( node == null ) {
            node = new Node( data );
        } else if( data < node.data ) {
            node.left = insert( node.left, data );
            node.left.parent = node;
        } else {
            node.right = insert( node.right, data );
            node.right.parent = node;
        }
        return node;
    }

    private void swap( Node a, Node b ) {

        if( a.parent == null ) {
            root = b;
        } else if( a == a.parent.left ) {
            a.parent.left = b;
        } else {
            a.parent.right = b;
        }

        if( b != null ) {
            b.parent = a.parent;
        }
    }

    public void delete( int data ) {
        delete( root, data );
    }

    public void delete( Node node, int data ) {

        if( node == null ) {
            return;
        }
        else if ( data == node.data) {
            if( node.left == null ) {
                swap( node, node.right ); 
            }
            else if( node.right == null ) {
                swap( node, node.left );
            }
            else {
                Node minNode = node.right;
                while( minNode.left != null ) {
                    minNode = minNode.left;
                }
                if( minNode.parent != node ) {
                    swap( minNode, minNode.right );
                    minNode.right = node.right;
                    minNode.right.parent = minNode;
                }

                swap( node, minNode );
                minNode.left = node.left;
                minNode.left.parent = minNode;
            }
        } 
        // Continue searching in the left subtree.
        else if( data < node.data) {
            delete( node.left, data );
        } 
        // Continue searching in the right subtree.
        else {
            delete( node.right, data );
        }
    }

    public boolean lookup( int data ) {
        return lookup( root, data );
    }

    public boolean lookup( Node node, int data ) {
        if( node == null ) {
            // Can't find it.
            return false;
        } else if( data == node.data) {
            // Found it.
            return true;
        } else if( data < node.data) {
            // Search left subtree.
            return lookup( node.left, data );
        } else {
            // Search right subtree.
            return lookup( node.right, data );
        }
    }

    public int minValue( ) {
        return minValue( root );
    }

    public int minValue( Node node ) {
        Node cursor = node;
        while( cursor.left != null ) {
            cursor = cursor.left;
        }
        return cursor.data;
    }

    public int maxValue( ) {
        return maxValue( root );
    }

    public int maxValue( Node node ) {
        Node cursor = node;
        while( cursor.right != null ) {
            cursor = cursor.right;
        }
        return cursor.data;
    }

    public void inorderTraversal( ) {
        inorderTraversal( root );
    }

    private void inorderTraversal( Node node ) {
        if( node != null ) {
            inorderTraversal( node.left );
            System.out.print( node.data + " " );
            inorderTraversal( node.right );
        }
    }

    public static void main( String[ ] args ) {
        BinarySearchTree bst = new BinarySearchTree( );
        int[ ] input = new int[ ] { 5, 10, 3, 9, 7, 8 , 1 , 4 , 6 , 10};

        for( int i : input ) {
            bst.insert( i );
        }

        bst.delete( 5 );
        bst.delete( 10 );
        bst.delete( 3 );
        bst.delete( 7 );

        System.out.println( "\n Sorted :" );
        bst.inorderTraversal( );

        System.out.println( "\nMax Value:" );
        System.out.println(bst.maxValue());
        System.out.println( "\n Min Value:" );
        System.out.println(bst.minValue());

        System.out.println(bst.lookup(1));
    }
}

公共类二进制搜索树{
私有节点根；
私有静态类节点{
节点父节点；
左淋巴结；
节点权；
int数据；
节点（int数据）{
这个数据=数据；
}
@凌驾
公共字符串toString（）{
返回“”+数据；
}
}
公共空白插入（整型数据）{
根=插入（根，数据）；
}
公共节点插入（节点，int数据）{
if（node==null）{
节点=新节点（数据）；
}else if（数据

这将为您提供1000个最小值和最大值之间的随机整数，包括最小值但不包括最大值

int MIN;
int MAX;
int[] randoms = new int[1000];
Random randGen = new Random();

for(int i = 0; i < randoms.length; i++)
{
    randoms[i] = MIN + randGen.nextInt(MAX - MIN));
}

int-MIN；
int MAX；
int[]randoms=新的int[1000]；
Random randGen=新的Random（）；
对于（int i=0；i

您可能对以下内容感兴趣：

---

请注意，

Random

只创建伪随机数，因此必须使用足够唯一的种子。

我支持java.util.Random建议。您真的要存储它们的数组，还是只需向随机生成器请求0到999之间的随机数，1000次？这里有一个函数来获取它们的数组，但我只想放弃数组并循环随机1000次

public static int[] generateRandomNumbers( int size ) {
    if ( size <= 0 ) {
        throw new IllegalArgumentException( "size must be greater than 0" );
    }
    Random random = new Random( System.currentTimeMillis() );
    int[] results = new int[ size ];
    for ( int i = 0; i < size; i++ ) {
        results[ i ] = random.nextInt( size );
    }
    return results;
}

---

你试过用谷歌搜索“java随机数”吗？看看java的快速检查：我用这段代码生成公共静态最终空主（字符串[]Args）{log（“生成范围为0..99的10个随机整数”）；//注意这里重用了一个随机对象random randomGenerator=new random（）；对于（int idx=1；idx我发布了我的代码，请帮助我，因为我没有任何关于random Genar的背景信息请查看上面以“…或者…”开头的简介，了解如何处理您的main（）到

public static int[] generateRandomNumbers( int size ) {
    if ( size <= 0 ) {
        throw new IllegalArgumentException( "size must be greater than 0" );
    }
    Random random = new Random( System.currentTimeMillis() );
    int[] results = new int[ size ];
    for ( int i = 0; i < size; i++ ) {
        results[ i ] = random.nextInt( size );
    }
    return results;
}

public static void main( String[] args ) {
    BinarySearchTree bst = new BinarySearchTree();
    int[] randoms = generateRandomNumbers( 1000 );
    for ( int i : randoms ) {
        bst.insert( i );
    }

    bst.delete( randoms[ 5 ] );
    bst.delete( randoms[ 10 ] );
    bst.delete( randoms[ 3 ] );
    bst.delete( randoms[ 7 ] );

    System.out.println( "\n Sorted :" );
    bst.inorderTraversal();

    System.out.println( "\nMax Value:" );
    System.out.println( bst.maxValue() );
    System.out.println( "\n Min Value:" );
    System.out.println( bst.minValue() );

    System.out.println( bst.lookup( randoms[ 1 ] ) );
    System.out.println( bst.lookup( randoms[ 999 ] ) );
}