Java 如何使用比较器计算ArrayList中的最小字符串？

我需要在MinTester类中编写一个静态方法来计算“最小”字符串 从使用comparator对象的ArrayList集合：

public static String min(ArrayList<String> list, Comparator<String> comp)

公共静态字符串最小值（ArrayList，Comparator comp）

我无法使用Collections类来计算最小值

这是我到目前为止所拥有的

public class MinTester
{

static String least;//This is static because it is being used in a static static context


public static String min(ArrayList<String> list, Comparator<String> comp)
{
   int min = 0;


  for( int i = 0; i < list.size(); i++ )
  {
    min = list.get(i).compareTo(list.get(i++));
    if(min < 0)
    {
        least = list.get(i);
    }
    else if(min == 0)
    {
        least = list.get(i);
    }
    else
    {
    least = list.get(i++);
    }
  }
    return least;
}
}

公共类
{
静态字符串least；//这是静态的，因为它正在静态上下文中使用
公共静态字符串最小值（ArrayList，Comparator comp）
{
int min=0；
对于（int i=0；i

我之所以使用最小值，是因为我了解到无论第一个字符串小于、等于或大于第二个字符串，compareTo方法都会返回负值、0或正值

我没有从这个方法中得到任何错误，所以我试着用这个来测试它。 我收到这样的警告：“访问静态方法min”

publicstaticvoidmain（字符串[]args）
{
//此处的TODO代码应用程序逻辑
MinTester s=新的MinTester（）；
比较器comp=null；
ArrayList=新建ArrayList（）；
列表。添加（“a”）；
列表。添加（“ab”）；
列表。添加（“abc”）；
列表。添加（“abcd”）；
字符串a=s.min（list，comp）；//警告：正在访问静态方法min
系统输出打印项次（a）；
}

---

a=“abcd”的我的输出。有人能帮我弄清楚为什么列表中的'Min'字符串是“abcd”？我认为我的错误来自我的min（）方法，但我不知道它在哪里，也不知道为什么。

如果需要在

数组列表中找到最短的
字符串
，而不进行排序，只需遍历列表并检查每个
字符串的
.length
属性，始终跟踪最短的一个

String shortest = list.get(0);

for(String str : list) {
    if (str.length() < shortest.length()) {
        shortest = str;
    }
}
System.out.println("The shortest string: " + shortest);

借

if（comp.compare（str，shortest）<0））

这基本上是一样的，只是你没有自己定义比较，而是让
比较器来决定这两个字符串中哪个更小。这样，如果您希望将来比较字符串的方式，您就不必重写该方法，如果您需要在
数组列表中查找最短的
字符串而无需对其排序，则只需提供不同的
比较器，您只需遍历列表并检查每个
字符串的
.length
属性，始终跟踪最短的字符串

String shortest = list.get(0);

for(String str : list) {
    if (str.length() < shortest.length()) {
        shortest = str;
    }
}
System.out.println("The shortest string: " + shortest);

借

if（comp.compare（str，shortest）<0））

这基本上是一样的，只是你没有自己定义比较，而是让
比较器来决定这两个字符串中哪个更小。这样，如果您希望将来比较字符串的方式，您就不必重写该方法，您只需使用
比较器提供不同的
比较器
一些指针即可。我不打算解决整个问题，因为这显然是您的家庭作业（为
字符串
长度实现
比较器
，了解
比较器#compareTo（T，T）
返回的内容，阅读
比较器
API）：

公共静态字符串最小值（列表、比较器comp）{
字符串最短=空；
用于（当前字符串：列表）{
如果（最短==null）{//第一次迭代
最短=电流；
继续；
}
int comparisonResult=组件比较（最短，当前）；
//TODO:您的任务；根据比较结果更新最短的任务
}
返回时间最短；
}
一些指针，使用
比较器来获得想法。我不打算解决整个问题，因为这显然是您的家庭作业（为
字符串
长度实现
比较器
，了解
比较器#compareTo（T，T）
返回的内容，阅读
比较器
API）：

公共静态字符串最小值（列表、比较器comp）{
字符串最短=空；
用于（当前字符串：列表）{
如果（最短==null）{//第一次迭代
最短=电流；
继续；
}
int comparisonResult=组件比较（最短，当前）；
//TODO:您的任务；根据比较结果更新最短的任务
}
返回时间最短；
}
您可以使用length方法获取字符串元素的长度

e.g. list.get(0).length()

这将返回字符串的大小

祝您好运
您可以使用length方法获得string元素的长度

e.g. list.get(0).length()

这将返回字符串的大小

祝您好运
我不想为您完成所有工作，因此我将提供Scala解决方案：

object MinTest{

  def main(args: Array[String]){
    val list: util.List[String] = List("a", "ab", "abc", "abcd")
    val m: String = min(list, (s1, s2) => s1.length - s2.length)
    println(m) //output is: a
  }

  def min(list: util.List[String], comp: (String, String) => Int): String = {
    if(list.isEmpty)
      return null
    var min = list(0)
    for(i <- 0 until list.size if comp(list(i), min) < 0)
      min = list(i)
    min
  }
}

objectmintest{
def main（参数：数组[字符串]）{
val list:util.list[字符串]=列表（“a”、“ab”、“abc”、“abcd”）
val m:String=min（列表，（s1，s2）=>s1.length-s2.length）
println（m）//输出为：a
}
def min（list:util.list[String]，comp:（String，String）=>Int:String={
if（list.isEmpty）
返回空
var最小值=列表（0）
因为（i不想为您完成所有工作，所以我将提供Scala中的解决方案：

object MinTest{

  def main(args: Array[String]){
    val list: util.List[String] = List("a", "ab", "abc", "abcd")
    val m: String = min(list, (s1, s2) => s1.length - s2.length)
    println(m) //output is: a
  }

  def min(list: util.List[String], comp: (String, String) => Int): String = {
    if(list.isEmpty)
      return null
    var min = list(0)
    for(i <- 0 until list.size if comp(list(i), min) < 0)
      min = list(i)
    min
  }
}

objectmintest{
def main（参数：数组[字符串]）{
val list:util.list[字符串]=列表（“a”、“ab”、“abc”、“abcd”）
val m:String=min（列表，（s1，s2）=>s1.length-s2.length）
println（m）//输出为：a
}
def min（list:util.list[String]，comp:（String，String）=>Int:String={
if（list.isEmpty）
返回空
var最小值=列表（0）
对于（我这很简单的家伙，你不能从一个列表中创建一个hashmap，其中hashmap中的数字是
object MinTest{

  def main(args: Array[String]){
    val list: util.List[String] = List("a", "ab", "abc", "abcd")
    val m: String = min(list, (s1, s2) => s1.length - s2.length)
    println(m) //output is: a
  }

  def min(list: util.List[String], comp: (String, String) => Int): String = {
    if(list.isEmpty)
      return null
    var min = list(0)
    for(i <- 0 until list.size if comp(list(i), min) < 0)
      min = list(i)
    min
  }
}

Comparator<String> comparator = (str1, str2) -> str1.length() > str2.length() ? 1 : -1;
    String smallest = Arrays.stream(input)
            .sorted(comparator).findFirst().get();