hashmap都是泛 型集合（使用hashmap储存多个企鹅信息）

本文目录

• 使用hashmap储存多个企鹅信息
• 用泛型将五个学生姓名,成绩写入一个hashmap集合中
• Map集合：HashMap、TreeMap
• 创建一个HashMap泛型对象，添加学员姓名分数，键为学员姓名值为学员对象，从HashMap中用迭代器打印学员成绩
• 泛型，HashMap,爆类型转换错误
• Java泛型集合哪些
• 用泛型将五个学生姓名,成绩写入一个hashmap集合中求出学生成绩的最高值,最低分平均分，总分，
• .一个泛型Map集合HashMap,往内分别添加三本图片, 分别设置相应的编

使用hashmap储存多个企鹅信息

使用HashMap存储10个企鹅信息。然后统一使用lterator进行遍历。在上机3的基础上，为企鹅添加一个编号，并作为键存储多个企鹅信息到应用泛型的HashMap集合。使用Iterator、foreach语句进行遍历。

用泛型将五个学生姓名,成绩写入一个hashmap集合中

import java.util.HashMap;
public class HelloWorld
{
    public static void main(String args)
    {
        HashMap《String,Integer》 stus=new HashMap《String,Integer》();
        stus.put("AAA",95);
        stus.put("BBB",85);
        stus.put("CCC",75);
        stus.put("ABC",99);
        stus.put("CBA",100);
        
        for(HashMap.Entry《String, Integer》 entry : stus.entrySet())
        {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+" "+value);
        }
    }
}

Map集合：HashMap、TreeMap

HashMap是基于哈希表的Map接口的非同步实现。实现HashMap对数据的操作，允许有一个null键，多个null值。

HashMap底层就是一个数组结构，数组中的每一项又是一个链表。数组+链表结构，新建一个HashMap的时候，就会初始化一个数组。Entry就是数组中的元素，每个Entry其实就是一个key-value的键值对，它持有一个指向下一个元素的引用，这就构成了链表，HashMap底层将key-value当成一个整体来处理，这个整体就是一个Entry对象。HashMap底层采用一个Entry【】数组来保存所有的key-value键值对，当需要存储一个Entry对象时，会根据hash算法来决定在其数组中的位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry对象时，也会根据hash算法找到其在数组中的存储位置， 在根据equals方法从该位置上的链表中取出Entry;

put： （key-value）方法是HashMap中最重要的方法，使用HashMap最主要使用的就是put，get两个方法。

判断键值对数组table是否为空或者为null，否则执行resize（）进行扩容；
根据键值key计算hash值得到插入的数组索引 i ,如果table 不为空，则转向3；
判断table 的首个元素是否和key一样，如果相同（hashCode和equals）直接覆盖value，否则转向4；
判断table是否为红黑树，如果是红黑树，则直接插入键值对，否则转向5；
遍历table , 判断链表长度是否大于8，大于8的话把链表转换成红黑树 ，进行插入操作，否则进行链表插入操作；便利时遇到相同key直接覆盖value；
插入成功后，判断实际存在的键值对数量size是否超过了threshold，如果超过，则扩容；

也可参考HashSetput过程：
***隐藏网址***

get方法取值过程：

指定key通过hash函数得到key的hash值；
调用内部方法getNode（），得到桶号（一般为hash值对桶数求摸）；
比较桶的内部元素是否和key相等，如不相等，则没有找到，相等，则取出相等记录的value；
如果得到key所在桶的头结点恰好是红黑树节点，就调用红黑树节点的getTreeNode（）方法，否则就遍历链表节点。getTreeNode（）方法通过调用树形节点的find（）方法进行查找。由于之前添加时已经保证这个树是有序的，因此查找时基本就是折半查找，效率高；
如果对比节点的哈希值和要查找的哈希值相等，就会判断key是否相等，相等就直接返回；不相等就从子树中递归查找；
HashMap中直接地址用hash函数生成，冲突用比较函数解决。如果每个桶内部只有一个元素，那么查找的时候只有一次比较。当许多桶内没有值得时候，许多查询就会更快

实现了SortedMap接口，是一个有序的集合，是一个红黑树接口，每个key-vlaue作为红黑树的节点，没有指定顺序则是根据key执行自然排序。默认自然排序

implements NavigableMap《K,V》, Cloneable, java.io.Serializable
可以自然排序，可以定制排序，Entry root = null 红黑树的根节点；size存放键值对的数量。

put():
get():根据不同的排序比较方法定位需要的数据，检索速度时间复杂度为O(log(n))；

remove():

TreeMap默认是自然排序，没有查找方法；无需遍历

是一个更高效检索二叉树，每个节点只能是红色或者黑色；根节点永远是黑色；所有叶子的子节点都是空节点，并且都是黑色；每个红色节点的两个子节点都是黑色，没有连续的红色节点；从人一个节点到其子树中的每个叶子节点的路径中所包含相同数量的黑色节点。

（1）HashMap:适用于在Map中插入、删除和定位元素。 默认乱序
（2）Treemap:适用于按自然顺序或自定义顺序遍历键（key）。 默认自然排序，如果插入的是基本类型，按照 大小排序。如果是引用类型，则按照插入顺序
（3）HashMap通常比TreeMap快一点（树和哈希表的数据结构使然），建议多使用HashMap, 在需要排序的Map时候才用TreeMap.**
（4）HashMap 非线程安全 TreeMap 非线程安全
（5）HashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。

在HashMap中通过get（）来获取value,通过put（）来插入value,ContainsKey（）则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。

Treemap的方法是在hashmap的基础上进行补充的

创建一个HashMap泛型对象，添加学员姓名分数，键为学员姓名值为学员对象，从HashMap中用迭代器打印学员成绩

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
public class Test {
public static void main(String args) {
Map《String, Student》 students = new HashMap《String, Student》();
students.put("aaa", new Student(60));
students.put("bbb", new Student(70));
students.put("ccc", new Student(80));
for (Entry《String, Student》 entry : students.entrySet()) {
System.out.println("姓名:" + entry.getKey() + " 成绩:" + entry.getValue());
}
}
}
class Student {
public Student(int point) {
this.point = point;
}
private int point;
public int getPoint() {
return point;
}
public void setPoint(int point) {
this.point = point;
}
@Override
public String toString() {
return String.valueOf(this.point);
}
}

泛型，HashMap,爆类型转换错误

您好，HashMap;
aTweightList = new HashMap《String, Float》();
分析：（同样摘自该帖子，解释的还可以，除了编译器不承认HashMap《K,V》这种形式是错的外，都没什么问题，事实上，便一起时承认这种写法的，但是基本上你不能使用这么定义的任何一个变量。）
1) 泛型是没有数组的。编译器不承认 HashMap《K,V》这种形式的：
Cannot create a generic array of HashMap《k,v》
原因就是数组必须确定他每一个元素的类型。但是泛型在编译阶段有一个类型擦除的问题，也就是说编译器理解 HashMap《Integer,Integer》和HashMap《String,String》都是同一种类型 HashMap。如果泛型数组存在，那么HashMap《Integer,Integer》和 HashMap《String,String》对象都可以加入到同一个HashMap数组中，这会造成灾难性的结果。
***隐藏网址***
如果一定要定义HashMap数组，可以使用HashMap; 形式，也就是HashMap常规类型。
(2) 对于没有初始化的类对象，系统会给予一个null值。但是调用null对象，一定会报NullPointerException异常的。养成随时初始化的好习惯。

Java泛型集合哪些

泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。
可以在集合框架（Collection framework）中看到泛型的动机。例如，Map 类允许您向一个 Map 添加任意类的对象，即使最常见的情况是在给定映射（map）中保存某个特定类型（比如 String）的对象。
因为 Map.get() 被定义为返回 Object，所以一般必须将 Map.get() 的结果强制类型转换为期望的类型，如下面的代码所示：
Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key");
要让程序通过编译，必须将 get() 的结果强制类型转换为 String，并且希望结果真的是一个 String。但是有可能某人已经在该映射中保存了不是 String 的东西，这样的话，上面的代码将会抛出 ClassCastException。
理想情况下，您可能会得出这样一个观点，即 m 是一个 Map，它将 String 键映射到 String 值。这可以让您消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。
泛型的好处
Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。这带来了很多好处：
类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。
Java 程序中的一种流行技术是定义这样的集合，即它的元素或键是公共类型的，比如“String 列表”或者“String 到 String 的映射”。通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了，而不是在运行时当作 ClassCastException 展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误，并可提高程序的可靠性。
消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
尽管减少强制类型转换可以降低使用泛型类的代码的罗嗦程度，但是声明泛型变量会带来相应的罗嗦。比较下面两个代码例子。
该代码不使用泛型：
List li = new ArrayList();
li.put(new Integer(3));
Integer i = (Integer) li.get(0);
该代码使用泛型：
List《Integer》 li = new ArrayList《Integer》();
li.put(new Integer(3));
Integer i = li.get(0);
在简单的程序中使用一次泛型变量不会降低罗嗦程度。但是对于多次使用泛型变量的大型程序来说，则可以累积起来降低罗嗦程度。
潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能。
由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。
泛型用法的例子
泛型的许多最佳例子都来自集合框架，因为泛型让您在保存在集合中的元素上指定类型约束。考虑这个使用 Map 类的例子，其中涉及一定程度的优化，即 Map.get() 返回的结果将确实是一个 String：
Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key");
如果有人已经在映射中放置了不是 String 的其他东西，上面的代码将会抛出 ClassCastException。泛型允许您表达这样的类型约束，即 m 是一个将 String 键映射到 String 值的 Map。这可以消除代码中的强制类型转换，同时获得一个附加的类型检查层，这个检查层可以防止有人将错误类型的键或值保存在集合中。
下面的代码示例展示了 JDK 5.0 中集合框架中的 Map 接口的定义的一部分：
public interface Map《K, V》 {
public void put(K key, V value);
public V get(K key);
}
注意该接口的两个附加物：
类型参数 K 和 V 在类级别的规格说明，表示在声明一个 Map 类型的变量时指定的类型的占位符。
在 get()、put() 和其他方法的方法签名中使用的 K 和 V。
为了赢得使用泛型的好处，必须在定义或实例化 Map 类型的变量时为 K 和 V 提供具体的值。以一种相对直观的方式做这件事：
Map《String, String》 m = new HashMap《String, String》();
m.put("key", "blarg");
String s = m.get("key");
当使用 Map 的泛型化版本时，您不再需要将 Map.get() 的结果强制类型转换为 String，因为编译器知道 get() 将返回一个 String。
在使用泛型的版本中并没有减少键盘录入；实际上，比使用强制类型转换的版本需要做更多键入。使用泛型只是带来了附加的类型安全。因为编译器知道关于您将放进 Map 中的键和值的类型的更多信息，所以类型检查从执行时挪到了编译时，这会提高可靠性并加快开发速度。
向后兼容
在 Java 语言中引入泛型的一个重要目标就是维护向后兼容。尽管 JDK 5.0 的标准类库中的许多类，比如集合框架，都已经泛型化了，但是使用集合类（比如 HashMap 和 ArrayList）的现有代码将继续不加修改地在 JDK 5.0 中工作。当然，没有利用泛型的现有代码将不会赢得泛型的类型安全好处。

用泛型将五个学生姓名,成绩写入一个hashmap集合中求出学生成绩的最高值,最低分平均分，总分，

import java.util.HashMap;
public class HelloWorld
{
    public static void main(String args)
    {
        HashMap《String,Integer》 stus=new HashMap《String,Integer》();
        stus.put("AAA",95);
        stus.put("BBB",85);
        stus.put("CCC",75);
        stus.put("ABC",99);
        stus.put("CBA",100);
        
        double tot=0,maxv=0,minv=0xfffffff;
        
        for(HashMap.Entry《String, Integer》 entry : stus.entrySet())
        {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+" "+value);
            tot+=value;
            if(value》maxv)
                maxv=value;
            if(value《minv)
                minv=value;
        }
        System.out.println("Highest:"+maxv);
        System.out.println("lowest:"+minv);
        System.out.println("avg:"+tot/5);
    }
}

运行结果：

.一个泛型Map集合HashMap,往内分别添加三本图片, 分别设置相应的编

你这没有规定key是什么，我就举个例子以递增的整数Integer作为key，举例为：

public class TTTT {
public static void main(String args) {
Book book1 = new Book("《绿楼梦》", "张三");
Book book2 = new Book("《瞎游记》", "李四");
Book book3 = new Book("《火浒传》", "王五");
Map《Integer, Book》 map = new HashMap《》();
map.put(1, book1);
map.put(2, book2);
map.put(3, book3);
}
private static class Book {
private String name;
private String author;
Book(String name, String author) {
this.name = name;
this.author = author;
}
}
}

后续你可以自行遍历map查看map中的内容验证一下。