Java 如何生成可变数组大小？

所以我的程序是功能性的。我只想让它使用一个文本文件的二进制搜索，并确定它可以找到的最高索引号。如果找不到，它会找到下一个最大的，并将其设为负值。我的问题是现在生成的数组大小是11。这是因为我使用的文本文件中有多少整数。如果我不知道整数的数目呢？我知道有人建议列一个清单，但这不允许重复吗？ 为什么这部分代码：

while(scanner.hasNextInt()){
        arr[i++] = scanner.nextInt();}
    scanner.close();

是否不根据需要更改阵列大小

import java.util.Scanner;
import java.io.File;
import java.io.IOException;

public class BinarySearch {   
 public static int binarysearch(int[] arr, int key)
{
int lo = 0, hi = arr.length - 1;
{
    while (lo < hi) 
    {
        int mid = (lo + hi) / 2;
        if (arr[mid] <= key)
            lo = mid + 1;
        if (arr[mid] > key)
            hi = mid;
    }
    if (arr[lo] == key) {
        return lo;
    }
    else if ((arr[lo] != key) && (arr[lo-1] == key)){
        return lo - 1;
    }
    else{
    return (binarysearch( arr,(key-1))* - 1); 
} 
    }
} 



public static void main(String[] args) throws IOException{ {

    int k = Integer.parseInt(args[1]);
    Scanner scanner = new Scanner(new File(args[0]));

    int[] arr = new int[11];
    int i = 0;
    while(scanner.hasNextInt()){
        arr[i++] = scanner.nextInt();}
    scanner.close();

    System.out.println(binarysearch(arr, k));

}}
}

import java.util.Scanner；
导入java.io.File；
导入java.io.IOException；
公共类二进制搜索{
公共静态int二进制搜索（int[]arr，int-key）
{
int-lo=0，hi=arr.length-1；
{
while（lo

列表

A是一个常用的数组，而不是数组。具体来说，

List

的

ArrayList

实现由内部数组支持，并根据需要自动处理内部数组的重新大小调整或重新构建

List< Integer > integers = new ArrayList<>() ;
integers.add( 7 ) ;
integers.add( 11 ) ;

对于反向顺序：

Collections.reverse( integers ) ;

如果您大致知道列表最终可能需要的大小，则可以在实例化

ArrayList

时指定初始容量。设置初始容量有助于提高

ArrayList

的运行效率，但您不必担心这一点

int initialCapacity = ( myNumberOfThis * myNumberOfThat ) + 1 ;  // Whatever clues you have about possible size.
List< Integer > integers = new ArrayList<>( initialCapacity ) ;

int initialCapacity=（myNumberOfThis*myNumberOfThis）+1；//不管你对可能的尺寸有什么线索。
Listintegers=newarraylist（initialCapacity）；

看

---

如果要消除重复项，请使用

集合

。搜索堆栈溢出，因为这已被多次讨论。

列表的可能重复允许重复值。数组列表完全按照问题要求的方式调整数组大小。

int initialCapacity = ( myNumberOfThis * myNumberOfThat ) + 1 ;  // Whatever clues you have about possible size.
List< Integer > integers = new ArrayList<>( initialCapacity ) ;