一个函数 形参是List类型 如何实现不同类型如：List和List两种功能

一个函数 形参是List类型 如何实现List<Integer>和List<String>两种功能
如

static List remDup(List<String> list) 

和

static List remDup(List<Integer> list) 

两个函数作用是相同的，但是无法通过上述重载。

问题是list迭代时候需要用到不止it.next()，所以需要专门的变量来放置it.next()，可在变量声明时需要声明类型，如果不能重载，就不知道怎么判断it.next()的类型；

初学者……大神勿喷

13 个解决方案

#1

在jvm看来两个都是 List remDup(List) 存在歧义没法重载
两种方式：
1、使用不同返回值
2、改重载为static List<E> remDup(List<E> list) 
另外你的泛型要怎么强制转换为普通List？

#2

基本已经可以实现你所想的了，但是显得有些笨拙，如果能拆开最好还是拆开，看起来比较清晰。下面代码有部分是用java1.8写的,有注释,instanceof可以自行百度看看.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Created by puruidong on 2015/4/2.
 */
public class TestDemo {
    public static void main(String[] args) {
        //记住下面这个一定要用Integer,而不能用int,否则下面判断不了!!!
        /*Java 1.8 Version */
        //List<Integer>
        parse(Arrays.asList(new Integer [] {1,2,3,4,5,6,7,8,9,10})).forEach(System.out::println);

        //List<String>
        parse(Arrays.asList(new String [] {"12","2","3"})).forEach(System.out::println);

        /*Java 1.8 Version end. */

        /*----------------------------------------------------*/

        /*Java 1.7 Version   */
        //List<Integer>
        List<?> lists =  parse(Arrays.asList(new Integer [] {1,2,3,4,5,6,7,8,9,10}));

        //List<String>
        //List<?> lists =  parse(Arrays.asList(new String [] {"12","2","3"}));
        for (Object os :lists){
            System.out.println(os);
        }
        /*Java 1.7 Version  end */

    }


    private static List<? extends Object> parse(List<? extends  Object> list){
        if(list.size()==0){
            return null;
        }
        /**/
        List<Object> result = null ;
        //处理String.
        if(list.get(0) instanceof  String){
            //如果是String则增加一个Hello World到末尾.
            result = new ArrayList<>(list);
            result.add("hello world");
        }else if (list.get(0) instanceof  Integer){
            //处理Integer
             result = new ArrayList<>(list);
            result.add(5000000);
            /*
            * 处理更多的思路是:使用下面的循环遍历出里面的值强转为int.即可.
            for (Object os:list){
            int rs = (int)os;//或者使用int rs = Integer.valueOf(os.toString());
            //其他操作,不要在这里将修改后的值赋给list,否则报错.
        }
            */
        }
        return result ;
    }

}

#3

static List remDup(List<String> list) 

返回值是坯型，整个的泛型使用也就没什么意义了

解决方案的话，可以：

static List<String> remDupString(List<String> list) 
static List<Integer> remDupInteger(List<Integer> list) 

如果是所有类型通用的功能，可以

static <E> List<E> remDupString(List<E> list) 

如果是某种类型通用的功能，可以用接口或者通用父类型来限定范围，比如，如果必须是 Comparable 的：

static <E extends Comparable<E>> List<E> remDupString(List<E> list) 

那么方法内用 E 来声明的变量就可以调用 compareTo 方法

#4

引用 1 楼 qq118194716 的回复:

在jvm看来两个都是 List remDup(List) 存在歧义没法重载
两种方式：
1、使用不同返回值
2、改重载为static List<E> remDup(List<E> list) 
另外你的泛型要怎么强制转换为普通List？

实用不同返回值应该不是方法重载吧？

#5

引用 4 楼 csdn_mrsongyang 的回复:

Quote: 引用 1 楼 qq118194716 的回复:

在jvm看来两个都是 List remDup(List) 存在歧义没法重载
两种方式：
1、使用不同返回值
2、改重载为static List<E> remDup(List<E> list) 
另外你的泛型要怎么强制转换为普通List？

实用不同返回值应该不是方法重载吧？

仅仅在java泛型中成立~

#6

试试这种
public LIst remDup(List<? extends Serializable> list)
或者
public <E> List<E> remDup(List<E> list)

#7

泛型

#8

不知道list中的元素是Integer还是String？
对于你说的这种问题，通过 list.get() instanceof Integer就可以判断具体类型了撒，很难吗？

static <E> List<E> remDup(List<E> list) {
		for (E e : list) {
			if (e instanceof Integer) {
				//TODO
			} else if (e instanceof String) {
				//TODO
			}
		}
		return null;
	}
}

#9

为什么一定要重载？写成两个方法不就好了

#10

将参数定义为List<T>，
在方法体内部对类型进行判断，只对Int和String类型进行操作，

#11

上面说的用泛型是对的

#12

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Main {
	static <T> List<T> remDup(List<T> list) {
		for (T item : list) {
			System.out.println(item);
		}
		return list;
	}

	public static void main(String[] args) {
		List<Integer> listInt = new ArrayList<>(Arrays.asList(1, 6, 3, 89, 5));
		remDup(listInt);
		List<String> listStr = new ArrayList<>(Arrays.asList("one", "two", "four"));
		remDup(listStr);
	}
}

泛型解决。

#13

谢谢各位啦！