Java中的原始类型是什么？为什么我经常听到不应该在新代码中使用它们？

原始类型是Java语言的古老历史。最初有集合，它们只持有对象。对集合的每个操作都需要将对象强制转换为所需类型。

List aList = new ArrayList();
String s = "Hello World!";
aList.add(s);
String c = (String)aList.get(0);

虽然这在大多数时间都有效，但确实发生了错误

List aNumberList = new ArrayList();
String one = "1";//Number one
aNumberList.add(one);
Integer iOne = (Integer)aNumberList.get(0);//Insert ClassCastException here

旧的无类型集合无法强制执行类型安全，因此程序员必须记住他在集合中存储的内容。泛型是为了克服这个限制而发明的，开发人员只需声明一次存储的类型，编译器就会改为声明。

List<String> aNumberList = new ArrayList<String>();
aNumberList.add("one");
Integer iOne = aNumberList.get(0);//Compile time error
String sOne = aNumberList.get(0);//works fine

用于比较：

// Old style collections now known as raw types
List aList = new ArrayList(); //Could contain anything
// New style collections with Generics
List<String> aList = new ArrayList<String>(); //Contains only Strings

Comparable接口更复杂：

//raw, not type save can compare with Other classes
class MyCompareAble implements CompareAble
{
   int id;
   public int compareTo(Object other)
   {return this.id - ((MyCompareAble)other).id;}
}
//Generic
class MyCompareAble implements CompareAble<MyCompareAble>
{
   int id;
   public int compareTo(MyCompareAble other)
   {return this.id - other.id;}
}

请注意，无法使用原始类型的compareTo（MyCompareAble）实现CompareAbble接口。为什么不应该使用它们：

存储在集合中的任何对象都必须在使用之前进行强制转换使用泛型启用编译时检查使用原始类型与将每个值存储为Object相同

编译器的作用：泛型是向后兼容的，它们使用与原始类型相同的java类。神奇之处主要发生在编译时。

List<String> someStrings = new ArrayList<String>();
someStrings.add("one");
String one = someStrings.get(0);

将编译为：

List someStrings = new ArrayList();
someStrings.add("one"); 
String one = (String)someStrings.get(0);

这与直接使用原始类型时编写的代码相同。虽然我不确定CompareAble接口会发生什么，但我猜它会创建两个compareTo函数，一个接受MyCompareAbl，另一个接受Object并在强制转换后将其传递给第一个。

原始类型的替代方法是什么：使用泛型

当原始类型表达您想要表达的内容时，它们是很好的。

例如，取消序列化函数可能返回List，但它不知道列表的元素类型。所以List是这里合适的返回类型。

Java中的原始类型是什么？为什么我经常听到不应该在新代码中使用它们？

原始类型是Java语言的古老历史。最初有集合，它们只持有对象。对集合的每个操作都需要将对象强制转换为所需类型。

List aList = new ArrayList();
String s = "Hello World!";
aList.add(s);
String c = (String)aList.get(0);

虽然这在大多数时间都有效，但确实发生了错误

List aNumberList = new ArrayList();
String one = "1";//Number one
aNumberList.add(one);
Integer iOne = (Integer)aNumberList.get(0);//Insert ClassCastException here

旧的无类型集合无法强制执行类型安全，因此程序员必须记住他在集合中存储的内容。泛型是为了克服这个限制而发明的，开发人员只需声明一次存储的类型，编译器就会改为声明。

List<String> aNumberList = new ArrayList<String>();
aNumberList.add("one");
Integer iOne = aNumberList.get(0);//Compile time error
String sOne = aNumberList.get(0);//works fine

用于比较：

// Old style collections now known as raw types
List aList = new ArrayList(); //Could contain anything
// New style collections with Generics
List<String> aList = new ArrayList<String>(); //Contains only Strings

Comparable接口更复杂：

//raw, not type save can compare with Other classes
class MyCompareAble implements CompareAble
{
   int id;
   public int compareTo(Object other)
   {return this.id - ((MyCompareAble)other).id;}
}
//Generic
class MyCompareAble implements CompareAble<MyCompareAble>
{
   int id;
   public int compareTo(MyCompareAble other)
   {return this.id - other.id;}
}

请注意，无法使用原始类型的compareTo（MyCompareAble）实现CompareAbble接口。为什么不应该使用它们：

存储在集合中的任何对象都必须在使用之前进行强制转换使用泛型启用编译时检查使用原始类型与将每个值存储为Object相同

编译器的作用：泛型是向后兼容的，它们使用与原始类型相同的java类。神奇之处主要发生在编译时。

List<String> someStrings = new ArrayList<String>();
someStrings.add("one");
String one = someStrings.get(0);

将编译为：

List someStrings = new ArrayList();
someStrings.add("one"); 
String one = (String)someStrings.get(0);

这与直接使用原始类型时编写的代码相同。虽然我不确定CompareAble接口会发生什么，但我猜它会创建两个compareTo函数，一个接受MyCompareAbl，另一个接受Object并在强制转换后将其传递给第一个。

原始类型的替代方法是什么：使用泛型

什么是原始类型，为什么我经常听到不应该在新代码中使用它们？

“原始类型”是使用泛型类而不为其参数化类型指定类型参数，例如使用List而不是List＜String＞。当泛型引入Java时，几个类被更新为使用泛型。使用这些类作为“原始类型”（不指定类型参数）允许遗留代码仍然编译。

“原始类型”用于向后兼容。不建议在新代码中使用它们，因为使用带有类型参数的泛型类可以实现更强的类型，这反过来可能会提高代码的可理解性，并导致更早地发现潜在问题。

如果我们不能使用原始类型，还有什么替代方法？如何更好？

首选的替代方法是按预期使用泛型类-带有适当的类型参数（例如List＜String＞）。这允许程序员更具体地指定类型，向未来的维护人员传达关于变量或数据结构的预期用途的更多含义，并允许编译器强制执行更好的类型安全性。这些优点一起可以提高代码质量，并有助于防止引入一些编码错误。

例如，对于程序员希望确保名为“names”的List变量仅包含字符串的方法：

List<String> names = new ArrayList<String>();
names.add("John");          // OK
names.add(new Integer(1));  // compile error

我在做了一些示例练习后发现了这一页，并有着完全相同的困惑。

===============我根据示例提供的代码===============

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

    Map wordMap = new HashMap();
    if (args.length > 0) {
        for (int i = 0; i < args.length; i++) {
            countWord(wordMap, args[i]);
        }
    } else {
        getWordFrequency(System.in, wordMap);
    }
    for (Iterator i = wordMap.entrySet().iterator(); i.hasNext();) {
        Map.Entry entry = (Map.Entry) i.next();
        System.out.println(entry.getKey() + " :\t" + entry.getValue());
    }

=========================到此代码========================

public static void main(String[] args) throws IOException {
    // replace with TreeMap to get them sorted by name
    Map<String, Integer> wordMap = new HashMap<String, Integer>();
    if (args.length > 0) {
        for (int i = 0; i < args.length; i++) {
            countWord(wordMap, args[i]);
        }
    } else {
        getWordFrequency(System.in, wordMap);
    }
    for (Iterator<Entry<String, Integer>> i = wordMap.entrySet().iterator(); i.hasNext();) {
        Entry<String, Integer> entry =   i.next();
        System.out.println(entry.getKey() + " :\t" + entry.getValue());
    }

}

===============================================================================

这可能更安全，但花了4个小时来驳斥哲学。。。

原始类型是在使用泛型类型时缺少类型参数。

不应使用原始类型，因为它可能会导致运行时错误，例如将双精度值插入到一组int中。

Set set = new HashSet();
set.add(3.45); //ok

当从集合中检索内容时，你不知道会发生什么。让我们假设您希望它是所有整数，您将其转换为整数；当出现双3.45时，运行时出现异常。

将类型参数添加到Set后，您将立即收到编译错误。这种抢先错误允许您在运行时发生问题之前修复问题（从而节省时间和精力）。

Set<Integer> set = new HashSet<Integer>();
set.add(3.45); //NOT ok.