Java 使用泛型生成交换方法

我对我书中的一个基本概念感到困惑。我应该做一个方法交换（）；使用泛型与第一个和第二个交换位置。我相信我的方法是正确的，但是我将pair类中的代码从T，S更改为T，因为我遇到了错误，并认为这可以解决问题，但事实并非如此。我的问题是，我现在在演示类中遇到了很多编译时错误，我找不到解决方案

public class Pair<T>
    {
       private T first;
       private T second;



   public Pair(T firstElement, T secondElement)
   {
      first = firstElement;
      second = secondElement;
   }


   public T getFirst() { return first; }

   public T getSecond() { return second; }

  public void swap()
  {

   T temp = first;
    first = second;
    second = temp;
  }

   public String toString() { return "(" + first + ", " + second + ")"; }
}

公共类对
{
私人T优先；
二等兵；
公共对（T第一个元素，T第二个元素）
{
第一个=第一个元素；
第二个=第二个元素；
}
公共T getFirst（）{return first；}
公共T getSecond（）{return second；}
公共无效掉期（）
{
T温度=第一；
第一=第二；
秒=温度；
}
公共字符串toString（）{return“（“+first+”，“+second+”）；}
}

这是我得到的编译时错误

PairDemo.java:23: error: wrong number of type arguments; required 1
   public static Pair<String, Integer> firstContaining(
                     ^
PairDemo.java:6: error: wrong number of type arguments; required 1
      Pair<String, Integer> result = firstContaining(names, "a");
          ^
PairDemo.java:11: error: cannot find symbol
      swap();
      ^
  symbol:   method swap()
  location: class PairDemo
PairDemo.java:30: error: wrong number of type arguments; required 1
            return new Pair<String, Integer>(strings[i], i);
                           ^
PairDemo.java:33: error: wrong number of type arguments; required 1
      return new Pair<String, Integer>(null, -1);

PairDemo.java:23:错误：类型参数数量错误；必需的1
公共静态对(
^
java:6:错误：类型参数数目错误；必需1
Pair result=firstContaining（名称，“a”）；
^
java:11:错误：找不到符号
交换（）；
^
符号：方法交换（）
地点：PairDemo类
java:30:错误：类型参数数目错误；必需1
返回新的对（字符串[i]，i）；
^
java:33:错误：类型参数的数量错误；必需1
返回新对（null，-1）；

这是我的演示课

public class PairDemo
{
   public static void main(String[] args)
   {
      String[] names = { "Tom", "Diana", "Harry" };
      Pair<String, Integer> result = firstContaining(names, "a");
      System.out.println(result.getFirst());
      System.out.println("Expected: Diana");
      System.out.println(result.getSecond());
      System.out.println("Expected: 1");
      swap();
   }


   public static Pair<String, Integer> firstContaining(
      String[] strings, String sub)
   {
      for (int i = 0; i < strings.length; i++)
      {
         if (strings[i].contains(sub))
         {
            return new Pair<String, Integer>(strings[i], i);
         }
      }
      return new Pair<String, Integer>(null, -1);
   }
}

公共类PairDemo
{
公共静态void main（字符串[]args）
{
字符串[]名称={“汤姆”、“戴安娜”、“哈里”}；
Pair result=firstContaining（名称，“a”）；
System.out.println（result.getFirst（））；
System.out.println（“预期：Diana”）；
System.out.println（result.getSecond（））；
System.out.println（“预期：1”）；
交换（）；
}
公共静态对(
字符串[]字符串，字符串子字符串）
{
for（int i=0；i

如果希望Pair中的元素具有不同的类型，则必须使Pair类具有两个泛型参数：Pair和make second是类型为U的字段。Swap显然会返回一个Pair，并且不能排列此引用

就像

public Pair<U,T> swap() {
  return new Pair(second, first);
}

公共对交换（）{
返回新的一对（第二对，第一对）；
}

如果希望Pair中的元素具有不同的类型，则必须使Pair类具有两个泛型参数：Pair和make second是类型为U的字段。Swap显然会返回一个Pair，并且不能排列此引用

就像

public Pair<U,T> swap() {
  return new Pair(second, first);
}

公共对交换（）{
返回新的一对（第二对，第一对）；
}

您的

对

需要一种类型

T

，您提供两种：

String

和

Integer

您的

对

需要一种类型

T

，您提供两种：

String

和

Integer

我如何调用该方法？pair1=新对（“Foo”，3）；pairswappedpair1=pair1.swap（）；现在它是：swappedPair.first==3和swappedPair.second==“foo”我似乎无法理解这一点，因为我的书希望我修改pair类使其具有相同的类型，然后添加一个swap方法。我发现了一些有趣的东西。我调用了result.swap（）；从最后一个给我的方法，它从Diana，1到1，Diana进行了交换，这似乎完成了这个技巧。如果你想按照书中的内容，你谈论的是对，那么你就不能写一对字符串和一个数字，因为它们是不同的类型，你写类的方式只有一个是可以接受的。你的交换方法在那个ca中se正确。但是请注意，swap方法会修改对象的状态（“可变性”），这是专家程序员通常不喜欢的。当你读完你的书读到“有效Java”时，肯定会有人因为你的Java技能而雇佣你；）我该如何调用该方法呢？pair1=新Pair（“Foo”，3）；Pair swappedPair=pair1.swap（）；现在它是：swappedPair.first==3和swappedPair.second==“foo”我似乎无法理解这一点，因为我的书希望我修改pair类，使其具有相同的类型，然后添加一个swap方法。我发现了一些有趣的东西。我调用了result.swap（）；从上一个给我的方法，它从Diana，1到1，Diana进行了交换，这似乎已经完成了这个技巧。如果你想按照书中提到的配对，那么你不能写一对字符串和一个数字，因为它们是不同的类型，你写类的方式只有一个是可以接受的。在这种情况下，您的交换方法是正确的。但是请注意，swap方法会修改对象的状态（“可变性”），这是专家程序员通常不喜欢的。当你读完《高效Java》这本书时，肯定会有人因为你的Java技能而雇佣你；）